more random patches. who knows. main
authorMike Frysinger <vapier@gentoo.org>
Sun, 3 Apr 2016 00:26:54 +0000 (20:26 -0400)
committerMike Frysinger <vapier@gentoo.org>
Sun, 3 Apr 2016 00:26:54 +0000 (20:26 -0400)
29 files changed:
1510_all_glibc-hppa-no-asm-elf-header.patch [new file with mode: 0644]
35_all_uClibc-svn-mips-stat.patch [new file with mode: 0644]
5005_all_glibc-relative-linker-scripts.patch [new file with mode: 0644]
6530_all_sparc-glibc-2.3.6-socket-no-weak-alias.patch [new file with mode: 0644]
autotools.eclass.patch [new file with mode: 0644]
avp-cleanup.patch [new file with mode: 0644]
bash-3.1-ulimit.patch [new file with mode: 0644]
dropbear-0.45-urandom.patch [new file with mode: 0644]
elf.5.updates.patch [new file with mode: 0644]
elfutils-0.118-libelf-link.patch [new file with mode: 0644]
modutils-2.4.27-hppa.patch [new file with mode: 0644]
nasm-elf-visibility-r2.patch [new file with mode: 0644]
nios2-5.1.patch [new file with mode: 0644]
palo-1.14-build.patch [new file with mode: 0644]
pax-utils-grep-style.patch [new file with mode: 0644]
pycrypto-2.0.1-bindist.patch [new file with mode: 0644]
qdepends.patch [new file with mode: 0644]
readline-5.1-cleanups.patch [new file with mode: 0644]
sandbox-2.6-no-pch.patch [new file with mode: 0644]
scanelf-cache-stat.patch [new file with mode: 0644]
setuid-bind-now.patch [new file with mode: 0644]
slibgcc.patch [new file with mode: 0644]
smpeg-0.4.4-gcc41.patch [new file with mode: 0644]
toolchain.eclass.xgcc.patch [new file with mode: 0644]
uclibc-mips-revert-stat-sigaction.patch [new file with mode: 0644]
udhcp-close-fds.patch [new file with mode: 0644]
viewcvs-dev-help.patch [new file with mode: 0644]
warzone-configure-enable.patch [new file with mode: 0644]
wtf-20050505-updates.patch [new file with mode: 0644]

diff --git a/1510_all_glibc-hppa-no-asm-elf-header.patch b/1510_all_glibc-hppa-no-asm-elf-header.patch
new file mode 100644 (file)
index 0000000..38d6ffd
--- /dev/null
@@ -0,0 +1,27 @@
+--- ports/sysdeps/unix/sysv/linux/hppa/sys/procfs.h
++++ ports/sysdeps/unix/sysv/linux/hppa/sys/procfs.h
+@@ -33,7 +33,6 @@
+ #include <sys/types.h>
+ #include <sys/ucontext.h>
+ #include <sys/user.h>
+-#include <asm/elf.h>
+ __BEGIN_DECLS
+@@ -52,6 +50,16 @@
+    but more Linuxy, with things that Linux does not support and which
+    GDB doesn't really use excluded.  */
++
++#define ELF_NGREG 80    /* We only need 64 at present, but leave space
++                              for expansion. */
++typedef unsigned long elf_greg_t;
++typedef elf_greg_t elf_gregset_t[ELF_NGREG];
++
++#define ELF_NFPREG 32
++typedef double elf_fpreg_t;
++typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];
++
+ struct elf_prstatus
+   {
+     struct elf_siginfo pr_info;               /* Info associated with signal.  */
diff --git a/35_all_uClibc-svn-mips-stat.patch b/35_all_uClibc-svn-mips-stat.patch
new file mode 100644 (file)
index 0000000..3c64ccf
--- /dev/null
@@ -0,0 +1,50 @@
+------------------------------------------------------------------------
+r13027 | vapier | 2006-01-01 18:49:48 -0500 (Sun, 01 Jan 2006) | 1 line
+
+previous st_dev change from unsigned long (4bytes) to __dev_t (8bytes) needed to shrink the pads as well to maintain ABI compat
+------------------------------------------------------------------------
+Index: libc/sysdeps/linux/mips/bits/stat.h
+===================================================================
+--- libc/sysdeps/linux/mips/bits/stat.h        (revision 11026)
++++ libc/sysdeps/linux/mips/bits/stat.h        (revision 13027)
+@@ -37,7 +37,7 @@
+ struct stat
+   {
+       __dev_t st_dev;
+-    long int st_pad1[3];
++    long int st_pad1[2];
+ #ifndef __USE_FILE_OFFSET64
+     __ino_t st_ino;           /* File serial number.          */
+ #else
+@@ -49,12 +49,12 @@
+     __gid_t st_gid;           /* Group ID of the file's group.*/
+     __dev_t st_rdev;  /* Device number, if device.  */
+ #ifndef __USE_FILE_OFFSET64
+-    long int st_pad2[2];
++    long int st_pad2[1];
+     __off_t st_size;          /* Size of file, in bytes.  */
+     /* SVR4 added this extra long to allow for expansion of off_t.  */
+     long int st_pad3;
+ #else
+-    long int st_pad2[3];
++    long int st_pad2[2];
+     __off64_t st_size;                /* Size of file, in bytes.  */
+ #endif
+     /*
+@@ -81,14 +81,14 @@
+ struct stat64
+   {
+     __dev_t st_dev;
+-    long int st_pad1[3];
++    long int st_pad1[2];
+     __ino64_t st_ino;         /* File serial number.          */
+     __mode_t st_mode;         /* File mode.  */
+     __nlink_t st_nlink;               /* Link count.  */
+     __uid_t st_uid;           /* User ID of the file's owner. */
+     __gid_t st_gid;           /* Group ID of the file's group.*/
+     __dev_t st_rdev;  /* Device number, if device.  */
+-    long int st_pad2[3];
++    long int st_pad2[2];
+     __off64_t st_size;                /* Size of file, in bytes.  */
+     /*
+      * Actually this should be timestruc_t st_atime, st_mtime and
diff --git a/5005_all_glibc-relative-linker-scripts.patch b/5005_all_glibc-relative-linker-scripts.patch
new file mode 100644 (file)
index 0000000..d2c3645
--- /dev/null
@@ -0,0 +1,57 @@
+--- Makerules
++++ Makerules
+@@ -972,6 +972,14 @@ ifndef subdir
+ # We need to use absolute paths since otherwise local copies (if they exist)
+ # of the files are taken by the linker.
+ install: $(inst_libdir)/libc.so
++
++ifeq ($(slibdir),$(libdir))
++ldscript_slibdir =
++ldscript_libdir =
++else
++ldscript_slibdir = $(slibdir)/
++ldscript_libdir = $(libdir)/
++endif
+ $(inst_libdir)/libc.so: $(common-objpfx)format.lds \
+                       $(common-objpfx)libc.so$(libc.so-version) \
+                       $(inst_libdir)/$(patsubst %,$(libtype.oS),\
+@@ -981,9 +989,9 @@ $(inst_libdir)/libc.so: $(common-objpfx)
+        echo '   Use the shared library, but some functions are only in';\
+        echo '   the static library, so try that secondarily.  */';\
+        cat $<; \
+-       echo 'GROUP ( $(slibdir)/libc.so$(libc.so-version)' \
+-            '$(libdir)/$(patsubst %,$(libtype.oS),$(libprefix)$(libc-name))'\
+-            ' AS_NEEDED (' $(slibdir)/$(rtld-installed-name) ') )' \
++       echo 'GROUP ( $(ldscript_slibdir)libc.so$(libc.so-version)' \
++            '$(ldscript_libdir)$(patsubst %,$(libtype.oS),$(libprefix)$(libc-name))'\
++            ' AS_NEEDED (' $(ldscript_slibdir)$(rtld-installed-name) ') )' \
+       ) > $@.new
+       mv -f $@.new $@
+--- nptl/Makefile
++++ nptl/Makefile
+@@ -368,6 +368,13 @@ lib-noranlib: $(addprefix $(objpfx),$(ex
+ # of the files are taken by the linker.
+ install: $(inst_libdir)/libpthread.so
++ifeq ($(slibdir),$(libdir))
++ldscript_slibdir =
++ldscript_libdir =
++else
++ldscript_slibdir = $(slibdir)/
++ldscript_libdir = $(libdir)/
++endif
+ $(inst_libdir)/libpthread.so: $(common-objpfx)format.lds \
+                             $(objpfx)libpthread.so$(libpthread.so-version) \
+                             $(inst_libdir)/$(patsubst %,$(libtype.oS),\
+@@ -377,8 +384,8 @@ $(inst_libdir)/libpthread.so: $(common-o
+        echo '   Use the shared library, but some functions are only in';\
+        echo '   the static library, so try that secondarily.  */';\
+        cat $<; \
+-       echo 'GROUP ( $(slibdir)/libpthread.so$(libpthread.so-version)' \
+-            '$(libdir)/$(patsubst %,$(libtype.oS),$(libprefix)pthread)'\
++       echo 'GROUP ( $(ldscript_slibdir)libpthread.so$(libpthread.so-version)' \
++            '$(ldscript_libdir)$(patsubst %,$(libtype.oS),$(libprefix)pthread)'\
+             ')' \
+       ) > $@.new
+       mv -f $@.new $@
diff --git a/6530_all_sparc-glibc-2.3.6-socket-no-weak-alias.patch b/6530_all_sparc-glibc-2.3.6-socket-no-weak-alias.patch
new file mode 100644 (file)
index 0000000..ad65036
--- /dev/null
@@ -0,0 +1,60 @@
+2005-12-19  Ulrich Drepper  <drepper@redhat.com>
+
+       * sysdeps/unix/sysv/linux/sparc/sparc32/socket.S: Handle NO_WEAK_ALIAS.
+       * sysdeps/unix/sysv/linux/sparc/sparc64/socket.S: Likewise.
+       Patch by Clint Adams.
+
+===================================================================
+RCS file: /cvs/glibc/libc/sysdeps/unix/sysv/linux/sparc/sparc32/socket.S,v
+retrieving revision 1.10
+retrieving revision 1.11
+diff -u -r1.10 -r1.11
+--- libc/sysdeps/unix/sysv/linux/sparc/sparc32/socket.S        2003/08/31 17:23:11     1.10
++++ libc/sysdeps/unix/sysv/linux/sparc/sparc32/socket.S        2005/12/20 06:25:23     1.11
+@@ -40,7 +40,11 @@
+    The .S files for the other calls just #define socket and #include this.  */
+ #ifndef __socket
+-#define __socket P(__,socket)
++# ifndef NO_WEAK_ALIAS
++#  define __socket P(__,socket)
++# else
++#  define __socket socket
++# endif
+ #endif
+ .globl __socket
+@@ -105,4 +109,6 @@
+ END (__socket)
++#ifndef NO_WEAK_ALIAS
+ weak_alias (__socket, socket)
++#endif
+===================================================================
+RCS file: /cvs/glibc/libc/sysdeps/unix/sysv/linux/sparc/sparc64/socket.S,v
+retrieving revision 1.4
+retrieving revision 1.5
+diff -u -r1.4 -r1.5
+--- libc/sysdeps/unix/sysv/linux/sparc/sparc64/socket.S        2004/12/16 16:47:49     1.4
++++ libc/sysdeps/unix/sysv/linux/sparc/sparc64/socket.S        2005/12/20 06:25:24     1.5
+@@ -40,7 +40,11 @@
+    The .S files for the other calls just #define socket and #include this.  */
+ #ifndef __socket
+-#define __socket P(__,socket)
++# ifndef NO_WEAK_ALIAS
++#  define __socket P(__,socket)
++# else
++#  define __socket socket
++# endif
+ #endif
+ .globl __socket
+@@ -107,4 +111,6 @@
+ END (__socket)
++#ifndef NO_WEAK_ALIAS
+ weak_alias (__socket, socket)
++#endif
diff --git a/autotools.eclass.patch b/autotools.eclass.patch
new file mode 100644 (file)
index 0000000..0cf0b68
--- /dev/null
@@ -0,0 +1,93 @@
+Index: autotools.eclass
+===================================================================
+RCS file: /var/cvsroot/gentoo-x86/eclass/autotools.eclass,v
+retrieving revision 1.56
+diff -u -p -r1.56 autotools.eclass
+--- autotools.eclass   1 Nov 2006 10:58:46 -0000       1.56
++++ autotools.eclass   4 Nov 2006 10:13:05 -0000
+@@ -20,6 +20,8 @@ if [[ -n ${WANT_AUTOMAKE} ]]; then
+               latest) _automake_atom="|| ( =sys-devel/automake-1.10* =sys-devel/automake-1.9* )" ;;
+               *) _automake_atom="=sys-devel/automake-${WANT_AUTOMAKE}*" ;;
+       esac
++      [[ ${WANT_AUTOMAKE} == "latest" ]] && WANT_AUTOMAKE="1.10:1.9"
++      export WANT_AUTOMAKE
+ fi
+ if [[ -n ${WANT_AUTOCONF} ]] ; then
+@@ -27,6 +29,8 @@ if [[ -n ${WANT_AUTOCONF} ]] ; then
+               2.1) _autoconf_atom="=sys-devel/autoconf-${WANT_AUTOCONF}*" ;;
+               latest | 2.5) _autoconf_atom=">=sys-devel/autoconf-2.59" ;;
+       esac
++      [[ ${WANT_AUTOCONF} == "latest" ]] && WANT_AUTOCONF="2.5"
++      export WANT_AUTOCONF
+ fi
+ DEPEND="${_automake_atom}
+       ${_autoconf_atom}
+@@ -116,7 +120,6 @@ eaclocal() {
+               done
+       fi
+-      autotools_set_versions
+       [[ ! -f aclocal.m4 || -n $(grep -e 'generated.*by aclocal' aclocal.m4) ]] && \
+               autotools_run_tool aclocal "$@" ${aclocal_opts}
+ }
+@@ -142,7 +145,6 @@ _elibtoolize() {
+ eautoheader() {
+       # Check if we should run autoheader
+       [[ -n $(autotools_check_macro "AC_CONFIG_HEADERS") ]] || return 0
+-      autotools_set_versions
+       autotools_run_tool autoheader "$@"
+ }
+@@ -154,7 +156,6 @@ eautoconf() {
+               die "No configure.{ac,in} present!"
+       fi
+-      autotools_set_versions
+       autotools_run_tool autoconf "$@"
+ }
+@@ -163,7 +164,6 @@ eautomake() {
+       [[ -f Makefile.am ]] || return 0
+-      autotools_set_versions
+       if [[ -z ${FROM_EAUTORECONF} && -f Makefile.in ]]; then
+               local used_automake
+               local installed_automake
+@@ -188,35 +188,6 @@ eautomake() {
+       autotools_run_tool automake --add-missing --copy ${extra_opts} "$@"
+ }
+-autotools_set_versions() {
+-      [[ -n ${autotools_version_sets} ]] && return 0
+-
+-      if [[ -n ${WANT_AUTOCONF} ]]; then
+-              [[ ${WANT_AUTOCONF} == "latest" ]] && WANT_AUTOCONF="2.5"
+-              export WANT_AUTOCONF
+-              einfo "Requested autoconf ${WANT_AUTOCONF}"
+-              einfo "Using $(autoconf --version 2>/dev/null | head -n 1)"
+-              einfo "Using $(autoheader --version 2>/dev/null | head -n 1)"
+-      fi
+-
+-      if [[ -n ${WANT_AUTOMAKE} ]]; then
+-              local latest_automake
+-              if [[ ${WANT_AUTOMAKE} == "latest" ]]; then
+-                      latest_automake="latest: "
+-                      for amver in 1.10 1.9 1.8 1.7 1.6; do
+-                              WANT_AUTOMAKE="${amver}"
+-                              ROOT=/ has_version =sys-devel/automake-${amver}* && break
+-                      done
+-              fi
+-              export WANT_AUTOMAKE
+-              einfo "Requested automake ${latest_automake}${WANT_AUTOMAKE}"
+-              einfo "Using $(automake --version 2>/dev/null | head -n 1)"
+-              einfo "Using $(aclocal --version 2>/dev/null | head -n 1)"
+-      fi
+-
+-      autotools_version_sets="yes"
+-}
+-
+ # Internal function to run an autotools' tool
+ autotools_run_tool() {
+       local STDERR_TARGET="${T}/$$.out"
diff --git a/avp-cleanup.patch b/avp-cleanup.patch
new file mode 100644 (file)
index 0000000..7f23ec0
--- /dev/null
@@ -0,0 +1,735 @@
+- change all 'unsigned int' vars that are used with ffreadbuf() to 'size_t'
+- create headers with prototypes to get ride of implicit warnings
+  main.h smacker.h avp/win95/winmain.h win95/dd_func.h
+- declare all the render funcs as using a const char for the textPtr (only
+  some do atm instead of all of them)
+- fix warning in LoadWavFromFastFile about pointer ... func returns a bool
+- fix pointer warning in opengl.c
+- use %p instead of %x when outputting pointers
+- tweak how debug vars are declared to get rid of 'unused variable' warnings
+- cast the 2nd param to an int in avp/support/coordstr.cpp to get rid of
+  implicit double->int cast warning
+- use a regular C cast instead of CXX in win95/hash_tem.hpp to get rid of
+  error about losing precision
+
+Index: main.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/main.c,v
+retrieving revision 1.65
+diff -u -p -r1.65 main.c
+--- main.c     12 Jan 2004 20:39:35 -0000      1.65
++++ main.c     12 Dec 2005 22:50:24 -0000
+@@ -43,6 +43,7 @@
+ #include "progress_bar.h"
+ #include "scrshot.hpp"
+ #include "version.h"
++#include "main.h"
+ char LevelName[] = {"predbit6\0QuiteALongNameActually"}; /* the real way to load levels */
+Index: menus.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/menus.c,v
+retrieving revision 1.9
+diff -u -p -r1.9 menus.c
+--- menus.c    9 Jan 2002 23:07:34 -0000       1.9
++++ menus.c    12 Dec 2005 22:50:24 -0000
+@@ -290,7 +290,7 @@ static void LoadMenuFont()
+ {
+       AVPMENUGFX *gfxPtr;
+       char buffer[100];
+-      unsigned int fastFileLength;
++      size_t fastFileLength;
+       void const *pFastFileData;
+       
+       IntroFont_Light.height = 33;
+@@ -600,7 +600,7 @@ int RenderMenuText_Clipped(char *textPtr
+ }
+-static int RenderSmallFontString(char *textPtr,int sx,int sy,int alpha, int red, int green, int blue)
++static int RenderSmallFontString(const char *textPtr,int sx,int sy,int alpha, int red, int green, int blue)
+ {
+       unsigned char *srcPtr;
+       unsigned short *destPtr;
+@@ -851,10 +851,10 @@ Determine area used by text , so we can 
+       if(output_y) *output_y=sy;
+ }
+-int RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format)
++int RenderSmallMenuText(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format)
+ {
+       int length;
+-      char *ptr;
++      const char *ptr;
+       
+       switch(format) {
+               default:
+@@ -889,10 +889,10 @@ int RenderSmallMenuText(char *textPtr, i
+       return RenderSmallFontString(textPtr,x,y,alpha,ONE_FIXED,ONE_FIXED,ONE_FIXED);
+ }
+-int RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue)
++int RenderSmallMenuText_Coloured(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue)
+ {
+       int length;
+-      char *ptr;
++      const char *ptr;
+       
+       switch(format) {
+               default:
+@@ -1050,7 +1050,7 @@ void LoadAvPMenuGfx(enum AVPMENUGFX_ID m
+ {
+       AVPMENUGFX *gfxPtr;
+       char buffer[100];
+-      unsigned int fastFileLength;
++      size_t fastFileLength;
+       void const *pFastFileData;
+       
+       GLOBALASSERT(menuGfxID < MAX_NO_OF_AVPMENUGFXS);
+Index: openal.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/openal.c,v
+retrieving revision 1.24
+diff -u -p -r1.24 openal.c
+--- openal.c   10 Aug 2003 02:38:08 -0000      1.24
++++ openal.c   12 Dec 2005 22:50:24 -0000
+@@ -1029,7 +1029,7 @@ int LoadWavFromFastFile(int soundNum, ch
+               strcpy (buf, wavFileName);
+               ffread (&buf[strlen(wavFileName)+1], len, 1, fp);
+               ffclose (fp);
+-              len = (int)ExtractWavFile (soundNum, buf);              
++              len = (ExtractWavFile (soundNum, buf) == NULL ? 0 : 1);
+               free (buf);
+       }
+Index: opengl.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/opengl.c,v
+retrieving revision 1.40
+diff -u -p -r1.40 opengl.c
+--- opengl.c   15 Oct 2003 06:10:42 -0000      1.40
++++ opengl.c   12 Dec 2005 22:50:25 -0000
+@@ -334,7 +334,7 @@ static void CheckTriangleBuffer(int rver
+               FlushTriangleBuffers(0);
+       }
+-      if ((int)tex != -1)
++      if (tex != (D3DTexture *)-1)
+               CheckBoundTextureIsCorrect(tex);
+       if (mode != -1)
+               CheckTranslucencyModeIsCorrect(mode);
+@@ -1598,7 +1598,7 @@ void D3D_RenderHUDNumber_Centred(unsigne
+       } while (--noOfDigits);
+ }
+-void D3D_RenderHUDString(char *stringPtr,int x,int y,int colour)
++void D3D_RenderHUDString(const char *stringPtr,int x,int y,int colour)
+ {
+       struct VertexTag quadVertices[4];
+@@ -1809,7 +1809,7 @@ void RenderStringVertically(char *string
+       }
+ }
+-int Hardware_RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format) 
++int Hardware_RenderSmallMenuText(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format) 
+ {
+       switch(format)
+       {
+@@ -1825,7 +1825,7 @@ int Hardware_RenderSmallMenuText(char *t
+               case AVPMENUFORMAT_RIGHTJUSTIFIED:
+               {
+                       int length = 0;
+-                      signed char *ptr = textPtr;
++                      const signed char *ptr = textPtr;
+                       while(*ptr)
+                       {
+@@ -1838,7 +1838,7 @@ int Hardware_RenderSmallMenuText(char *t
+               case AVPMENUFORMAT_CENTREJUSTIFIED:
+               {
+                       int length = 0;
+-                      signed char *ptr = textPtr;
++                      const signed char *ptr = textPtr;
+                       while(*ptr)
+                       {
+@@ -1861,7 +1861,7 @@ int Hardware_RenderSmallMenuText(char *t
+       return x;
+ }
+-int Hardware_RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue)
++int Hardware_RenderSmallMenuText_Coloured(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue)
+ {
+       switch(format)
+       {
+@@ -1877,7 +1877,7 @@ int Hardware_RenderSmallMenuText_Coloure
+               case AVPMENUFORMAT_RIGHTJUSTIFIED:
+               {
+                       int length = 0;
+-                      signed char *ptr = textPtr;
++                      const signed char *ptr = textPtr;
+                       while(*ptr)
+                       {
+@@ -1890,7 +1890,7 @@ int Hardware_RenderSmallMenuText_Coloure
+               case AVPMENUFORMAT_CENTREJUSTIFIED:
+               {
+                       int length = 0;
+-                      signed char *ptr = textPtr;
++                      const signed char *ptr = textPtr;
+                       while(*ptr)
+                       {
+Index: avp/avpview.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/avpview.c,v
+retrieving revision 1.6
+diff -u -p -r1.6 avpview.c
+--- avp/avpview.c      18 Dec 2001 02:23:40 -0000      1.6
++++ avp/avpview.c      12 Dec 2005 22:50:25 -0000
+@@ -9,6 +9,7 @@
+ #include "avpview.h"
+ #include "opengl.h"
++#include "smacker.h"
+ #include "kshape.h"
+ #include "kzsort.h"
+ #include "frustum.h"
+Index: avp/bh_near.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/bh_near.c,v
+retrieving revision 1.4
+diff -u -p -r1.4 bh_near.c
+--- avp/bh_near.c      22 Dec 2001 00:49:58 -0000      1.4
++++ avp/bh_near.c      12 Dec 2005 22:50:26 -0000
+@@ -1646,7 +1646,7 @@ static void AlienNearState_Retreat(STRAT
+               if (targetModule) {
+                       //textprint("Target module is %s\n",targetModule->name);
+-                      textprint("Target AI module found, %x.\n",(int)targetModule);
++                      textprint("Target AI module found, %p.\n",targetModule);
+               } else {
+                       textprint("Target module is NULL!\n");
+               }
+@@ -1830,7 +1830,7 @@ static void AlienNearState_Hunt(STRATEGY
+               if (targetModule) {
+                       //textprint("Target module is %s\n",targetModule->name);
+-                      textprint("Target AI module for hunt found, %x.\n",(int)targetModule);
++                      textprint("Target AI module for hunt found, %p.\n",targetModule);
+               } else {
+                       textprint("Target module is NULL!\n");
+               }
+Index: avp/bh_queen.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/bh_queen.c,v
+retrieving revision 1.6
+diff -u -p -r1.6 bh_queen.c
+--- avp/bh_queen.c     22 May 2003 00:23:07 -0000      1.6
++++ avp/bh_queen.c     12 Dec 2005 22:50:27 -0000
+@@ -505,10 +505,9 @@ void MakeQueenFar(STRATEGYBLOCK *sbPtr) 
+       /* get the queen's status block */
+       int i;
+-      QUEEN_STATUS_BLOCK *queenStatusPointer= (QUEEN_STATUS_BLOCK *)(sbPtr->SBdataptr);    
+       LOCALASSERT(sbPtr);
+-    LOCALASSERT(queenStatusPointer);
++    LOCALASSERT((QUEEN_STATUS_BLOCK *)(sbPtr->SBdataptr));
+       LOCALASSERT(sbPtr->SBdptr != NULL);
+       /* get rid of the displayblock */
+Index: avp/bh_waypt.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/bh_waypt.c,v
+retrieving revision 1.3
+diff -u -p -r1.3 bh_waypt.c
+--- avp/bh_waypt.c     22 Dec 2001 00:49:58 -0000      1.3
++++ avp/bh_waypt.c     12 Dec 2005 22:50:27 -0000
+@@ -131,7 +131,7 @@ int NPCGetWaypointDirection(WAYPOINT_HEA
+       //Base shift value on strategy block so that the aliens don't keep changing their minds
+       //about which route to take
+-      GlobalLinkShift=(((int)sbPtr)&0xffff)>>4;
++      GlobalLinkShift=(((size_t)sbPtr)&0xffff)>>4;
+       if (FindBestRoute(&current_route,waypoints)==0) {
+               /* Yuck! */
+               textprint("Waypoint dropout: no continuous route!\n");
+Index: avp/dynamics.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/dynamics.c,v
+retrieving revision 1.4
+diff -u -p -r1.4 dynamics.c
+--- avp/dynamics.c     22 Dec 2001 00:49:58 -0000      1.4
++++ avp/dynamics.c     12 Dec 2005 22:50:28 -0000
+@@ -43,8 +43,10 @@ you should have seen the previous versio
+ #if 0
+       extern int GlobalFrameCounter;
+       #define LogInfo LOGDXFMT
++      #define LogInfoVar(x) x
+ #else
+       #define LogInfo(args) (void)0
++      #define LogInfoVar(x)
+ #endif
+ extern MORPHDISPLAY MorphDisplay;
+@@ -295,7 +297,7 @@ extern void ObjectDynamics(void)
+       InitialiseDynamicObjectsList();
+       {
+-              DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr;
++              LogInfoVar(DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr);
+               LogInfo
+               ((
+                       "Dynamics Logging: frame %d\nDL: player's Position %d,%d,%d\nDL: player's Displacement %d,%d,%d\nDL: NormalFrameTime %d\n",
+Index: avp/game.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/game.c,v
+retrieving revision 1.7
+diff -u -p -r1.7 game.c
+--- avp/game.c 22 Dec 2001 00:49:58 -0000      1.7
++++ avp/game.c 12 Dec 2005 22:50:28 -0000
+@@ -10,6 +10,7 @@
+ #include "dynblock.h"
+ #include "dynamics.h"
++#include "winmain.h"
+ #include "bh_types.h"
+ #include "bh_alien.h"
+ #include "pheromon.h"
+Index: avp/psndproj.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/psndproj.c,v
+retrieving revision 1.6
+diff -u -p -r1.6 psndproj.c
+--- avp/psndproj.c     9 Jan 2002 23:07:35 -0000       1.6
++++ avp/psndproj.c     12 Dec 2005 22:50:28 -0000
+@@ -856,7 +856,7 @@ int FindAndLoadWavFile(int soundNum,char
+ #if LOAD_SOUND_FROM_FAST_FILE
+       //first look in fast file
+       {
+-              unsigned nLen;
++              size_t nLen;
+               if(ffreadbuf(sound_name,&nLen))
+               {
+                       return LoadWavFromFastFile(soundNum,sound_name);
+Index: avp/pvisible.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/pvisible.c,v
+retrieving revision 1.3
+diff -u -p -r1.3 pvisible.c
+--- avp/pvisible.c     9 Jan 2002 23:07:35 -0000       1.3
++++ avp/pvisible.c     12 Dec 2005 22:50:29 -0000
+@@ -236,7 +236,7 @@ void DoObjectVisibility(STRATEGYBLOCK *s
+                 module. However, we will do a paranoia check for a null containingModule... */ 
+                 if(!sbPtr->containingModule)    
+                 {
+-                        textprint("Calling Far EmergencyRelocateObject, On object %x, type %d!\n",(int)sbPtr, sbPtr->I_SBtype);
++                        textprint("Calling Far EmergencyRelocateObject, On object %p, type %d!\n",sbPtr, sbPtr->I_SBtype);
+                         IdentifyObject(sbPtr);
+                         if(!(EmergencyRelocateObject(sbPtr))) {
+                                 textprint("Relocate failed!\n");
+@@ -432,7 +432,7 @@ void DoObjectVisibility(STRATEGYBLOCK *s
+                 if(!(newModule))
+                 {
+                         /* attempt to relocate object */
+-                        textprint("Calling Near EmergencyRelocateObject, On object %x, type %d!\n",(int)sbPtr, sbPtr->I_SBtype);
++                        textprint("Calling Near EmergencyRelocateObject, On object %p, type %d!\n",sbPtr, sbPtr->I_SBtype);
+                         IdentifyObject(sbPtr);
+                         if(!(EmergencyRelocateObject(sbPtr))) {
+                                 textprint("Relocate failed!\n");
+Index: avp/savegame.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/savegame.c,v
+retrieving revision 1.7
+diff -u -p -r1.7 savegame.c
+--- avp/savegame.c     22 May 2003 00:23:07 -0000      1.7
++++ avp/savegame.c     12 Dec 2005 22:50:29 -0000
+@@ -8,6 +8,7 @@
+ #include "comp_shp.h"
+ #include "dynblock.h"
++#include "smacker.h"
+ #include "bh_alien.h"
+ #include "pvisible.h"
+ #include "bh_pred.h"
+Index: avp/weapons.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/weapons.c,v
+retrieving revision 1.8
+diff -u -p -r1.8 weapons.c
+--- avp/weapons.c      22 May 2003 00:23:07 -0000      1.8
++++ avp/weapons.c      12 Dec 2005 22:50:31 -0000
+@@ -10138,8 +10138,7 @@ SECTION_DATA *CheckBiteIntegrity(void) {
+       if ((targetpos.vz >0) 
+               && (targetpos.vz <  (BITE_RANGE<<1))) {
+       
+-              DYNAMICSBLOCK *dynPtr = Biting->DynPtr;
+-              GLOBALASSERT(dynPtr);
++              GLOBALASSERT(Biting->DynPtr);
+               
+               if (IsThisObjectVisibleFromThisPosition_WithIgnore(objectPtr,Player,&Global_VDB_Ptr->VDB_World,(BITE_RANGE<<1))) {
+       
+Index: avp/support/coordstr.cpp
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/support/coordstr.cpp,v
+retrieving revision 1.3
+diff -u -p -r1.3 coordstr.cpp
+--- avp/support/coordstr.cpp   9 Jan 2002 23:07:35 -0000       1.3
++++ avp/support/coordstr.cpp   12 Dec 2005 22:50:31 -0000
+@@ -210,7 +210,7 @@ ACTIVITY_RETURN_TYPE AcyclicPulsingCoord
+       textprint("AcyclicPulsingCoordinate :: Activity(%i)\n", FixP_Time);
+       #endif
+-      int Int_CurrentCoord_Old = Int_CurrentCoord_Val;
++      ACTIVITY_RVAL_TEMP(int Int_CurrentCoord_Old = Int_CurrentCoord_Val);
+       ApplyVelocity( FixP_Time );
+@@ -276,7 +276,7 @@ ACTIVITY_RETURN_TYPE CyclicPulsingCoordi
+       textprint("CyclicPulsingCoordinate :: Activity(%i)\n", FixP_Time);
+       #endif
+-      int Int_CurrentCoord_Old = Int_CurrentCoord_Val;
++      ACTIVITY_RVAL_TEMP(int Int_CurrentCoord_Old = Int_CurrentCoord_Val);
+       
+       ApplyVelocity( FixP_Time );
+       
+@@ -343,7 +343,7 @@ HomingCoordinate::HomingCoordinate
+       FixP_IdealVelocity_Val = DIV_FIXED
+       (
+               (FixP_TargetCoord_Val - FixP_Position_Val),
+-              FIXP_SECONDS_FOR_STANDARD_HOMING
++              (int)FIXP_SECONDS_FOR_STANDARD_HOMING
+       );
+ }
+@@ -383,7 +383,7 @@ AcyclicHomingCoordinate :: AcyclicHoming
+ ACTIVITY_RETURN_TYPE AcyclicHomingCoordinate :: Activity(ACTIVITY_INPUT)
+ {
+-      int Int_CurrentCoord_Old = Int_CurrentCoord_Val;
++      ACTIVITY_RVAL_TEMP(int Int_CurrentCoord_Old = Int_CurrentCoord_Val);
+       #if 0
+       textprint("acyclic homing coord for time %i\n",FixP_Time);
+@@ -503,7 +503,7 @@ void AcyclicHomingCoordinate :: SetTarge
+       
+       FixP_IdealVelocity_Val = DIV_FIXED(
+               (FixP_TargetCoord_Val - FixP_Position_Val),
+-              FIXP_SECONDS_FOR_STANDARD_HOMING
++              (int)FIXP_SECONDS_FOR_STANDARD_HOMING
+       );
+       
+@@ -553,7 +553,7 @@ AcyclicFixedSpeedHoming :: ~AcyclicFixed
+ ACTIVITY_RETURN_TYPE AcyclicFixedSpeedHoming :: Activity(ACTIVITY_INPUT)
+ {
+-      int Int_CurrentCoord_Old = Int_CurrentCoord_Val;
++      ACTIVITY_RVAL_TEMP(int Int_CurrentCoord_Old = Int_CurrentCoord_Val);
+       #if 0
+       textprint("acyclic homing coord for time %i\n",FixP_Time);
+Index: avp/support/daemon.h
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/support/daemon.h,v
+retrieving revision 1.2
+diff -u -p -r1.2 daemon.h
+--- avp/support/daemon.h       29 Jul 2001 02:29:46 -0000      1.2
++++ avp/support/daemon.h       12 Dec 2005 22:50:31 -0000
+@@ -30,12 +30,14 @@
+       #if SupportCallbackHooks
+               #define ACTIVITY_RETURN_TYPE    OurBool
++              #define ACTIVITY_RVAL_TEMP(b)   b
+               #define ACTIVITY_RVAL_CHANGE    {return Yes;}
+               #define ACTIVITY_RVAL_NOCHANGE  {return No;}
+               #define ACTIVITY_RVAL_BOOL(b)   {return b;}
+       #else
+               #define ACTIVITY_RETURN_TYPE            void
++              #define ACTIVITY_RVAL_TEMP(b)
+               #define ACTIVITY_RVAL_CHANGE            {return;}
+               #define ACTIVITY_RVAL_NOCHANGE          {return;}
+               #define ACTIVITY_RVAL_BOOL(ignore)      {return;}
+Index: avp/win95/progress_bar.cpp
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/win95/progress_bar.cpp,v
+retrieving revision 1.10
+diff -u -p -r1.10 progress_bar.cpp
+--- avp/win95/progress_bar.cpp 22 Dec 2001 00:49:59 -0000      1.10
++++ avp/win95/progress_bar.cpp 12 Dec 2005 22:50:31 -0000
+@@ -59,7 +59,7 @@ void Start_Progress_Bar()
+               CL_GetImageFileName(buffer, 100,Loading_Bar_Empty_Image_Name, LIO_RELATIVEPATH);
+               
+               //see if graphic can be found in fast file
+-              unsigned int fastFileLength;
++              size_t fastFileLength;
+               void const * pFastFileData = ffreadbuf(buffer,&fastFileLength);
+               
+               if(pFastFileData)
+@@ -89,7 +89,7 @@ void Start_Progress_Bar()
+               CL_GetImageFileName(buffer, 100,Loading_Bar_Full_Image_Name, LIO_RELATIVEPATH);
+               
+               //see if graphic can be found in fast file
+-              unsigned int fastFileLength;
++              size_t fastFileLength;
+               void const * pFastFileData = ffreadbuf(buffer,&fastFileLength);
+               
+               if(pFastFileData)
+@@ -128,7 +128,7 @@ void Start_Progress_Bar()
+       
+       //see if graphic can be found in fast file
+-      unsigned int fastFileLength;
++      size_t fastFileLength;
+       void const * pFastFileData = ffreadbuf(buffer,&fastFileLength);
+       
+       if(pFastFileData)
+Index: avp/win95/system.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/win95/system.c,v
+retrieving revision 1.10
+diff -u -p -r1.10 system.c
+--- avp/win95/system.c 9 Jan 2002 23:07:36 -0000       1.10
++++ avp/win95/system.c 12 Dec 2005 22:50:31 -0000
+@@ -12,6 +12,7 @@
+ #include "messagehistory.h"
+ #include "particle.h"
+ #include "pldnet.h"
++#include "smacker.h"
+ #define UseLocalAssert Yes
+ #include "ourasert.h"
+Index: avp/win95/frontend/avp_intro.cpp
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/win95/frontend/avp_intro.cpp,v
+retrieving revision 1.3
+diff -u -p -r1.3 avp_intro.cpp
+--- avp/win95/frontend/avp_intro.cpp   22 Dec 2001 00:49:59 -0000      1.3
++++ avp/win95/frontend/avp_intro.cpp   12 Dec 2005 22:50:31 -0000
+@@ -4,7 +4,8 @@ extern "C"
+       #include "3dc.h"
+       //#include "intro.hpp"
+       #include "inline.h"
+-      //#include "smacker.h"
++      #include "smacker.h"
++      #include "winmain.h"
+       #include "avp_menus.h"
+     #include "avp_intro.h"
+       extern int NormalFrameTime;
+@@ -24,7 +25,6 @@ void Show_ARebellionGame(void);
+ void Show_AvPLogo(void);
+ extern void ShowSplashScreens(void);
+ extern void Show_WinnerScreen(void);
+-extern void PlayBinkedFMV(char *filenamePtr);
+ extern void DrawMainMenusBackdrop(void);
+ extern void FadedScreen(int alpha);
+Index: avp/win95/frontend/avp_menugfx.cpp
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/win95/frontend/avp_menugfx.cpp,v
+retrieving revision 1.4
+diff -u -p -r1.4 avp_menugfx.cpp
+--- avp/win95/frontend/avp_menugfx.cpp 9 Jan 2002 23:07:36 -0000       1.4
++++ avp/win95/frontend/avp_menugfx.cpp 12 Dec 2005 22:50:32 -0000
+@@ -256,7 +256,7 @@ extern int RenderMenuText_Clipped(char *
+ }
+-extern int RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format) 
++extern int RenderSmallMenuText(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format) 
+ {
+       switch(format)
+       {
+@@ -300,7 +300,7 @@ extern int RenderSmallMenuText(char *tex
+       x = RenderSmallFontString(textPtr,x,y,alpha,ONE_FIXED,ONE_FIXED,ONE_FIXED);
+       return x;
+ }
+-extern int RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue) 
++extern int RenderSmallMenuText_Coloured(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue) 
+ {
+       switch(format)
+       {
+@@ -345,7 +345,7 @@ extern int RenderSmallMenuText_Coloured(
+       return x;
+ }
+-extern int Hardware_RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format) 
++extern int Hardware_RenderSmallMenuText(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format) 
+ {
+       switch(format)
+       {
+@@ -395,7 +395,7 @@ extern int Hardware_RenderSmallMenuText(
+       return x;
+ }
+-extern int Hardware_RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue)
++extern int Hardware_RenderSmallMenuText_Coloured(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue)
+ {
+       switch(format)
+       {
+Index: avp/win95/frontend/avp_menugfx.hpp
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/win95/frontend/avp_menugfx.hpp,v
+retrieving revision 1.6
+diff -u -p -r1.6 avp_menugfx.hpp
+--- avp/win95/frontend/avp_menugfx.hpp 9 Jan 2002 23:07:36 -0000       1.6
++++ avp/win95/frontend/avp_menugfx.hpp 12 Dec 2005 22:50:32 -0000
+@@ -99,11 +99,11 @@ extern void ReleaseAllAvPMenuGfx(void);
+ extern int RenderMenuText(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
+-extern int RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
+-extern int RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue); 
++extern int RenderSmallMenuText(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
++extern int RenderSmallMenuText_Coloured(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue); 
+-extern int Hardware_RenderSmallMenuText(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
+-extern int Hardware_RenderSmallMenuText_Coloured(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue);
++extern int Hardware_RenderSmallMenuText(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
++extern int Hardware_RenderSmallMenuText_Coloured(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int red, int green, int blue);
+ extern int RenderMenuText_Clipped(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int topY, int bottomY);
+ extern void RenderSmallFontString_Wrapped(const char *textPtr,RECT* area,int alpha,int* output_x,int* output_y);
+Index: avp/win95/frontend/avp_menus.c
+===================================================================
+RCS file: /cvs/cvsroot/avp/avp/win95/frontend/avp_menus.c,v
+retrieving revision 1.11
+diff -u -p -r1.11 avp_menus.c
+--- avp/win95/frontend/avp_menus.c     22 May 2003 01:55:16 -0000      1.11
++++ avp/win95/frontend/avp_menus.c     12 Dec 2005 22:50:33 -0000
+@@ -8,6 +8,10 @@
+ #include "net.h"
+ #include "opengl.h"
+ #include "pldnet.h"
++#include "main.h"
++#include "winmain.h"
++#include "smacker.h"
++#include "dd_func.h"
+ #include "avp_menudata.h"
+ #include "avp_menus.h"
+@@ -1788,7 +1792,7 @@ static void RenderLoadGameMenu(void)
+       AVPMENU_ELEMENT *elementPtr = AvPMenus.MenuElements;
+       int e;
+       int y;
+-      int (*RenderText)(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
++      int (*RenderText)(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
+       
+       if (AvPMenus.MenusState == MENUSSTATE_MAINMENUS)
+       {
+@@ -3224,8 +3228,8 @@ int LengthOfSmallMenuText(char *textPtr)
+ static void RenderMenuElement(AVPMENU_ELEMENT *elementPtr, int e, int y)
+ {
+-      int (*RenderText)(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
+-      int (*RenderText_Coloured)(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int r, int g, int b);
++      int (*RenderText)(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
++      int (*RenderText_Coloured)(const char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int r, int g, int b);
+       int (*MenuTextLength)(char *textPtr);
+       
+       if (AvPMenus.FontToUse==AVPMENU_FONT_BIG)
+Index: win95/chnktexi.cpp
+===================================================================
+RCS file: /cvs/cvsroot/avp/win95/chnktexi.cpp,v
+retrieving revision 1.4
+diff -u -p -r1.4 chnktexi.cpp
+--- win95/chnktexi.cpp 18 Dec 2001 05:08:53 -0000      1.4
++++ win95/chnktexi.cpp 12 Dec 2005 22:50:33 -0000
+@@ -102,7 +102,7 @@ static char * RiffBasename(Chunk_With_Ch
+ #if CL_SUPPORT_FASTFILE
+ static inline bool IsFileInFastFile(char const * pszFileName)
+ {
+-      unsigned nLen;
++      size_t nLen;
+       return ffreadbuf(pszFileName,&nLen) ? true : false;
+ }
+ #endif
+@@ -714,7 +714,7 @@ int CL_LoadImageOnce(char const * pszFil
+               case LIO_DDSURFACE:
+               {
+                       #if CL_SUPPORT_FASTFILE
+-                      unsigned nFastFileLen;
++                      size_t nFastFileLen;
+                       void const * pFastFileData = ffreadbuf(szBuf,&nFastFileLen);
+                       if (pFastFileData)
+                       {
+@@ -823,7 +823,7 @@ int CL_LoadImageOnce(char const * pszFil
+               {
+                       fAwLoad |= AW_TLF_COMPRESS; // required on some cards!!
+                       #if CL_SUPPORT_FASTFILE
+-                      unsigned nFastFileLen;
++                      size_t nFastFileLen;
+                       void const * pFastFileData = ffreadbuf(szBuf,&nFastFileLen);
+                       if (pFastFileData)
+                       {
+Index: win95/hash_tem.hpp
+===================================================================
+RCS file: /cvs/cvsroot/avp/win95/hash_tem.hpp,v
+retrieving revision 1.5
+diff -u -p -r1.5 hash_tem.hpp
+--- win95/hash_tem.hpp 18 Aug 2004 04:20:41 -0000      1.5
++++ win95/hash_tem.hpp 12 Dec 2005 22:50:33 -0000
+@@ -242,7 +242,7 @@
+       inline unsigned HashFunction(void const * const _vP)
+       {
+               // treat as integer
+-              return HashFunction(reinterpret_cast<unsigned>(_vP));
++              return HashFunction((unsigned long)(_vP));
+       }
+       // a hash function for strings
+--- /dev/null  2005-12-12 17:15:01.544366500 -0500
++++ main.h     2005-12-12 16:33:39.000000000 -0500
+@@ -0,0 +1,11 @@
++#ifndef __MAIN_H__
++#define __MAIN_H__
++
++extern void LoadDeviceAndVideoModePreferences(void);
++extern void SaveDeviceAndVideoModePreferences(void);
++extern void PreviousVideoMode2(void);
++extern void NextVideoMode2(void);
++extern char *GetVideoModeDescription2(void);
++extern char *GetVideoModeDescription3(void);
++
++#endif
+--- /dev/null  2005-12-12 17:15:01.544366500 -0500
++++ smacker.h  2005-12-12 16:29:16.000000000 -0500
+@@ -0,0 +1,11 @@
++#ifndef __SMACKER_H__
++#define __SMACKER_H__
++
++extern void GetFMVInformation(int *messageNumberPtr, int *frameNumberPtr);
++extern void InitialiseTriggeredFMVs(void);
++extern void StartFMVAtFrame(int number, int frame);
++extern void StartTriggerPlotFMV(int number);
++extern void UpdateAllFMVTextures(void);
++extern void EndMenuMusic(void);
++
++#endif
+--- /dev/null  2005-12-12 17:15:01.544366500 -0500
++++ avp/win95/winmain.h        2005-12-12 16:26:06.000000000 -0500
+@@ -0,0 +1,10 @@
++#ifndef __WINMAIN_H__
++#define __WINMAIN_H__
++
++extern void PlayBinkedFMV(char *filenamePtr);
++extern void StartMenuBackgroundBink(void);
++extern int PlayMenuBackgroundBink(void);
++extern void EndMenuBackgroundBink(void);
++extern void InitialiseTriggeredFMVs(void);
++
++#endif
+--- /dev/null  2005-12-12 17:15:01.544366500 -0500
++++ win95/dd_func.h    2005-12-12 16:34:43.000000000 -0500
+@@ -0,0 +1,6 @@
++#ifndef __DD_FUNC_H__
++#define __DD_FUNC_H__
++
++extern int SelectDirectDrawObject(void *pGUID);
++
++#endif
diff --git a/bash-3.1-ulimit.patch b/bash-3.1-ulimit.patch
new file mode 100644 (file)
index 0000000..f7add63
--- /dev/null
@@ -0,0 +1,151 @@
+Ripped from Fedora
+
+Add support for RLIMIT_NICE/RLIMIT_RTPRIO and add missing documentation
+for many other options
+
+--- builtins/ulimit.def
++++ builtins/ulimit.def
+@@ -34,18 +34,20 @@
+     -a        all current limits are reported
+     -c        the maximum size of core files created
+     -d        the maximum size of a process's data segment
++    -e        the maximum scheduling priority (`nice')
+     -f        the maximum size of files created by the shell
+-    -i  the maximum number of pending signals
++    -i        the maximum number of pending signals
+     -l        the maximum size a process may lock into memory
+     -m        the maximum resident set size
+     -n        the maximum number of open file descriptors
+     -p        the pipe buffer size
+-    -q  the maximum number of bytes in POSIX message queues
++    -q        the maximum number of bytes in POSIX message queues
++    -r        the maximum rt priority
+     -s        the maximum stack size
+     -t        the maximum amount of cpu time in seconds
+     -u        the maximum number of user processes
+     -v        the size of virtual memory
+-    -x  the maximum number of file locks
++    -x        the maximum number of file locks
+ If LIMIT is given, it is the new value of the specified resource;
+ the special LIMIT values `soft', `hard', and `unlimited' stand for
+@@ -202,6 +204,9 @@
+ #ifdef RLIMIT_DATA
+   { 'd',      RLIMIT_DATA,  1024,     "data seg size",        "kbytes" },
+ #endif
++#ifdef RLIMIT_NICE
++  { 'e',      RLIMIT_NICE,  1,        "max nice",     (char *)NULL},
++#endif
+   { 'f',      RLIMIT_FILESIZE, 1024,  "file size",            "blocks" },
+ #ifdef RLIMIT_SIGPENDING
+   { 'i',      RLIMIT_SIGPENDING, 1,   "pending signals",      (char *)NULL },
+@@ -217,6 +222,9 @@
+ #ifdef RLIMIT_MSGQUEUE
+   { 'q',      RLIMIT_MSGQUEUE, 1,     "POSIX message queues", "bytes" },
+ #endif
++#ifdef RLIMIT_RTPRIO
++  { 'r',      RLIMIT_RTPRIO, 1,       "max rt priority",      (char *)NULL},
++#endif
+ #ifdef RLIMIT_STACK
+   { 's',      RLIMIT_STACK, 1024,     "stack size",           "kbytes" },
+ #endif
+--- doc/bashref.texi
++++ doc/bashref.texi
+@@ -3833,7 +3833,7 @@
+ @item ulimit
+ @btindex ulimit
+ @example
+-ulimit [-acdflmnpstuvSH] [@var{limit}]
++ulimit [-acdefilmnpqrstuvxSH] [@var{limit}]
+ @end example
+ @code{ulimit} provides control over the resources available to processes
+ started by the shell, on systems that allow such control.  If an
+@@ -3854,9 +3854,15 @@
+ @item -d
+ The maximum size of a process's data segment.
++@item -e
++The maximum scheduling priority.
++
+ @item -f
+ The maximum size of files created by the shell.
++@item -i
++The maximum number of pending signals.
++
+ @item -l
+ The maximum size that may be locked into memory.
+@@ -3869,6 +3875,12 @@
+ @item -p
+ The pipe buffer size.
++@item -q
++The maximum number of bytes in POSIX message queues.
++
++@item -r
++The maximum RT priority.
++
+ @item -s
+ The maximum stack size.
+@@ -3881,6 +3893,9 @@
+ @item -v
+ The maximum amount of virtual memory available to the process.
++@item -x
++The maximum amount of file locks.
++
+ @end table
+ If @var{limit} is given, it is the new value of the specified resource;
+--- doc/bash.1
++++ doc/bash.1
+@@ -8484,7 +8484,7 @@
+ returns true if any of the arguments are found, false if
+ none are found.
+ .TP
+-\fBulimit\fP [\fB\-SHacdflmnpstuv\fP [\fIlimit\fP]]
++\fBulimit\fP [\fB\-SHacdefilmnpqrstuvx\fP [\fIlimit\fP]]
+ Provides control over the resources available to the shell and to
+ processes started by it, on systems that allow such control.
+ The \fB\-H\fP and \fB\-S\fP options specify that the hard or soft limit is
+@@ -8520,9 +8520,15 @@
+ .B \-d
+ The maximum size of a process's data segment
+ .TP
++.B \-e
++The maximum scheduling priority (`nice')
++.TP
+ .B \-f
+ The maximum size of files created by the shell
+ .TP
++.B \-i
++The maximum number of pending signals
++.TP
+ .B \-l
+ The maximum size that may be locked into memory
+ .TP
+@@ -8536,6 +8542,12 @@
+ .B \-p
+ The pipe size in 512-byte blocks (this may not be set)
+ .TP
++.B \-q
++The maximum number of bytes in POSIX message queues
++.TP
++.B \-r
++The maximum rt priority
++.TP
+ .B \-s
+ The maximum stack size
+ .TP
+@@ -8547,6 +8559,9 @@
+ .TP
+ .B \-v
+ The maximum amount of virtual memory available to the shell
++.TP
++.B \-x
++The maximum number of file locks
+ .PD
+ .PP
+ If
diff --git a/dropbear-0.45-urandom.patch b/dropbear-0.45-urandom.patch
new file mode 100644 (file)
index 0000000..e45c1ef
--- /dev/null
@@ -0,0 +1,57 @@
+--- dropbear-0.45.orig/options.h       2005-03-08 14:43:07.000000000 -0500
++++ dropbear-0.45/options.h    2005-03-08 14:44:41.000000000 -0500
+@@ -148,6 +148,10 @@
+ /* prngd must be manually set up to produce output */
+ /*#define DROPBEAR_PRNGD_SOCKET "/var/run/dropbear-rng"*/
++/* If the normal random source would block for a while, fall back to 
++ * the urandom source so that connections don't hang forever. */
++#define DROPBEAR_URANDOM_DEV "/dev/urandom"
++
+ /* Specify the number of clients we will allow to be connected but
+  * not yet authenticated. After this limit, connections are rejected */
+ #ifndef MAX_UNAUTH_CLIENTS
+diff -ur dropbear-0.45.orig/random.c dropbear-0.45/random.c
+--- dropbear-0.45.orig/random.c        2005-03-08 14:43:07.000000000 -0500
++++ dropbear-0.45/random.c     2005-03-08 14:57:31.000000000 -0500
+@@ -57,9 +57,14 @@
+       struct sockaddr_un egdsock;
+       char egdcmd[2];
+ #endif
++      mode_t readmode = O_RDONLY;
++#ifdef DROPBEAR_URANDOM_DEV
++      unsigned int readtries = 0;
++      readmode |= O_NONBLOCK;
++#endif
+ #ifdef DROPBEAR_RANDOM_DEV
+-      readfd = open(DROPBEAR_RANDOM_DEV, O_RDONLY);
++      readfd = open(DROPBEAR_RANDOM_DEV, readmode);
+       if (readfd < 0) {
+               dropbear_exit("couldn't open random device");
+       }
+@@ -97,6 +102,24 @@
+                       if (readlen < 0 && errno == EINTR) {
+                               continue;
+                       }
++#ifdef DROPBEAR_URANDOM_DEV
++                      /* if the main random source blocked, lets retry a few times, 
++                       * but then give up and try a constant random source. */
++                      if (readlen < 0 && errno == EAGAIN) {
++                              ++readtries;
++                              if (readtries < 5) {
++                                      sleep(1);
++                                      continue;
++                              } else if (readtries == 5) {
++                                      close (readfd);
++                                      readfd = open(DROPBEAR_URANDOM_DEV, readmode);
++                                      if (readfd < 0) {
++                                              dropbear_exit("couldn't open secondary random device");
++                                      }
++                                      continue;
++                              }
++                      }
++#endif
+                       dropbear_exit("error reading random source");
+               }
+               readpos += readlen;
diff --git a/elf.5.updates.patch b/elf.5.updates.patch
new file mode 100644 (file)
index 0000000..4f0e218
--- /dev/null
@@ -0,0 +1,89 @@
+--- man5/elf.5
++++ man5/elf.5
+@@ -584,6 +584,11 @@
+ Values less than or equal to
+ .Sy PT_LOPROC
+ are reserved for processor-specific semantics.
++.It PT_GNU_STACK
++GNU extension which is used by the Linux kernel to control the state of the
++stack via the flags set in the 
++.Sy p_flags
++member.
+ .El
+ .Pp
+ .It Dv p_offset
+@@ -606,7 +611,7 @@
+ This member holds the number of bytes in the memory image of the segment.
+ It may be zero.
+ .It Dv p_flags
+-This member holds flags relevant to the segment:
++This member holds a bitmask of flags relevant to the segment:
+ .Pp
+ .Bl -tag -width "PF_X" -compact
+ .It Dv PF_X
+@@ -998,6 +1003,25 @@
+ .Sy SHF_ALLOC
+ and
+ .Sy SHF_EXECINSTR .
++.It .gnu.version
++This section holds the version symbol table, an array of ElfN_Half elements.
++This section is of type
++.Sy SHT_GNU_versym .
++The attribute type used is
++.Sy SHF_ALLOC .
++.It .gnu.version_d
++This section holds the version symbol definitons, a table of ElfN_Verdef
++structures.  This section is of type
++.Sy SHT_GNU_verdef .
++The attribute type used is
++.Sy SHF_ALLOC .
++.It .gnu.version_r
++This section holds the version symbol needed elements, a table of
++ElfN_Verneed structures.  This section is of
++type
++.Sy SHT_GNU_versym .
++The attribute type used is
++.Sy SHF_ALLOC .
+ .It .got
+ This section holds the global offset table.
+ This section is of type
+@@ -1049,6 +1073,14 @@
+ .Sy .note.openbsd.ident
+ section to identify themselves, for the kernel to bypass any compatibility
+ ELF binary emulation tests when loading the file.
++.It .note.GNU-stack
++This section is used in Linux object files for declaring stack attributes.
++This section is of type
++.Sy SHT_PROGBITS .
++The only attribute used is
++.Sy SHF_EXECINSTR .
++This indicates to the GNU linker that the object file requires an
++executable stack.
+ .It .plt
+ This section holds the procedure linkage table.
+ This section is of type
+@@ -1271,7 +1301,23 @@
+ .El
+ .Pp
+ .It Dv st_other
+-This member currently holds zero and has no defined meaning.
++This member defines the symbol visibility.
++.Bl -tag -width "STV_PROTECTED"
++.It Dv STV_DEFAULT
++Default symbol visibility rules.
++.It Dv STV_INTERNAL
++Processor specific hidden class.
++.It Dv STV_HIDDEN
++Symbol is unavailable in other modules.
++.It Dv STV_PROTECTED
++Not preemptible, not exported.
++.Pp
++There are macros for extracting the visibility type:
++.Pp
++.Fn ELF32_ST_VISIBILITY other
++or
++.Fn ELF64_ST_VISIBILITY other
++.El
+ .It Dv st_shndx
+ Every symbol table entry is
+ .Dq defined
diff --git a/elfutils-0.118-libelf-link.patch b/elfutils-0.118-libelf-link.patch
new file mode 100644 (file)
index 0000000..9bb2d60
--- /dev/null
@@ -0,0 +1,36 @@
+libdw needs libelf
+
+http://bugs.gentoo.org/115385
+
+--- src/Makefile.am
++++ src/Makefile.am
+@@ -93,7 +93,7 @@
+ ld_LDFLAGS = -rdynamic
+ elflint_LDADD  = $(libebl) $(libelf) $(libeu) $(libmudflap) -ldl
+ findtextrel_LDADD = $(libdw) $(libelf) $(libmudflap)
+-addr2line_LDADD = $(libdw) $(libmudflap)
++addr2line_LDADD = $(libdw) $(libelf) $(libmudflap)
+ elfcmp_LDADD = $(libebl) $(libelf) $(libmudflap) -ldl
+ objdump_LDADD  = $(libebl) $(libelf) $(libeu) $(libmudflap) -ldl
+ ranlib_LDADD = $(libelf) $(libeu) $(libmudflap)
+--- tests/Makefile.am
++++ tests/Makefile.am
+@@ -160,12 +160,12 @@
+ get_aranges_LDADD = $(libdw) $(libelf) $(libmudflap)
+ allfcts_LDADD = $(libdw) $(libelf) $(libmudflap)
+ line2addr_no_Wformat = yes
+-line2addr_LDADD = $(libdw) $(libmudflap)
+-addrscopes_LDADD = $(libdw) $(libmudflap)
+-funcscopes_LDADD = $(libdw) $(libmudflap)
+-funcretval_LDADD = $(libdw) $(libmudflap)
+-allregs_LDADD = $(libdw) $(libmudflap)
+-find_prologues_LDADD = $(libdw) $(libmudflap)
++line2addr_LDADD = $(libdw) $(libelf) $(libmudflap)
++addrscopes_LDADD = $(libdw) $(libelf) $(libmudflap)
++funcscopes_LDADD = $(libdw) $(libelf) $(libmudflap)
++funcretval_LDADD = $(libdw) $(libelf) $(libmudflap)
++allregs_LDADD = $(libdw) $(libelf) $(libmudflap)
++find_prologues_LDADD = $(libdw) $(libelf) $(libmudflap)
+ #show_ciefde_LDADD = ../libdwarf/libdwarf.so $(libelf) $(libmudflap)
+ asm_tst1_LDADD = $(libasm) $(libebl) $(libelf) $(libmudflap) -ldl
+ asm_tst2_LDADD = $(libasm) $(libebl) $(libelf) $(libmudflap) -ldl
diff --git a/modutils-2.4.27-hppa.patch b/modutils-2.4.27-hppa.patch
new file mode 100644 (file)
index 0000000..30168d3
--- /dev/null
@@ -0,0 +1,12 @@
+fix support for hppa1.0-unknown-linux-gnu / hppa1.1-unknown-linux-gnu
+
+--- modutils-2.4.27/configure
++++ modutils-2.4.27/configure
+@@ -31,6 +31,7 @@
+   powerpc)   ARCH=ppc   ;;
+   powerpc64) ARCH=ppc64 ;;
+   hppa2*)    ARCH=hppa64 ;;
++  hppa*)     ARCH=hppa  ;;
+   *)         ARCH=$host_cpu ;;
+ esac
diff --git a/nasm-elf-visibility-r2.patch b/nasm-elf-visibility-r2.patch
new file mode 100644 (file)
index 0000000..d4f1948
--- /dev/null
@@ -0,0 +1,107 @@
+Add support for declaring elf visibility attributes.  Used to
+help cleanup TEXTRELs in misc libraries (like libsdl).
+
+Syntax to declare function foo hidden:
+GLOBAL foo:function hidden
+
+Patch by Mike Frysinger <vapier@gentoo.org>
+
+http://sourceforge.net/mailarchive/forum.php?thread_id=9230919&forum_id=4978
+
+--- nasm/output/outelf.c
++++ nasm/output/outelf.c
+@@ -50,6 +50,7 @@ struct Symbol {
+     long strpos;                /* string table position of name */
+     long section;               /* section ID of the symbol */
+     int type;                   /* symbol type */
++    int other;                  /* symbol visibility */
+     long value;                 /* address, or COMMON variable align */
+     long size;                  /* size of symbol */
+     long globnum;               /* symbol table offset if global */
+@@ -113,9 +114,15 @@ extern struct ofmt of_elf;
+ #define SYM_SECTION 0x04
+ #define SYM_GLOBAL 0x10
++#define SYM_NOTYPE 0x00
+ #define SYM_DATA 0x01
+ #define SYM_FUNCTION 0x02
++#define STV_DEFAULT 0
++#define STV_INTERNAL 1
++#define STV_HIDDEN 2
++#define STV_PROTECTED 3
++
+ #define GLOBAL_TEMP_BASE 16     /* bigger than any constant sym id */
+ #define SEG_ALIGN 16            /* alignment of sections in file */
+@@ -493,6 +500,7 @@ static void elf_deflabel(char *name, lon
+     sym->strpos = pos;
+     sym->type = is_global ? SYM_GLOBAL : 0;
++    sym->other = STV_DEFAULT;
+     sym->size = 0;
+     if (segment == NO_SEG)
+         sym->section = SHN_ABS;
+@@ -570,18 +578,39 @@ static void elf_deflabel(char *name, lon
+             sym->next = sects[sym->section - 1]->gsyms;
+             sects[sym->section - 1]->gsyms = sym;
++            /* ELF syntax: GLOBAL name[:type [visibility]] */
+             if (special) {
+-                int n = strcspn(special, " ");
+-
++                int n = strcspn(special, " \t");
+                 if (!nasm_strnicmp(special, "function", n))
+                     sym->type |= SYM_FUNCTION;
+                 else if (!nasm_strnicmp(special, "data", n) ||
+                          !nasm_strnicmp(special, "object", n))
+                     sym->type |= SYM_DATA;
++                else if (!nasm_strnicmp(special, "notype", n))
++                    sym->type |= SYM_NOTYPE;
+                 else
+                     error(ERR_NONFATAL, "unrecognised symbol type `%.*s'",
+                           n, special);
++                special += n;
++
++                while (isspace(*special))
++                    ++special;
++                if (*special) {
++                    n = strcspn(special, " \t");
++                    if (!nasm_strnicmp(special, "default", n))
++                        sym->other = STV_DEFAULT;
++                    else if (!nasm_strnicmp(special, "internal", n))
++                        sym->other = STV_INTERNAL;
++                    else if (!nasm_strnicmp(special, "hidden", n))
++                        sym->other = STV_HIDDEN;
++                    else if (!nasm_strnicmp(special, "protected", n))
++                        sym->other = STV_PROTECTED;
++                    else
++                        n = 0;
++                    special += n;
++                }
++
+-                if (special[n]) {
++                if (*special) {
+                     struct tokenval tokval;
+                     expr *e;
+                     int fwd = FALSE;
+@@ -1120,7 +1149,8 @@ static struct SAA *elf_build_symtab(long
+         WRITELONG(p, sym->strpos);
+         WRITELONG(p, sym->value);
+         WRITELONG(p, sym->size);
+-        WRITESHORT(p, sym->type);       /* local non-typed thing */
++        WRITECHAR(p, sym->type);       /* local non-typed thing */
++        WRITECHAR(p, sym->other);
+         WRITESHORT(p, sym->section);
+         saa_wbytes(s, entry, 16L);
+         *len += 16;
+@@ -1138,7 +1168,8 @@ static struct SAA *elf_build_symtab(long
+         WRITELONG(p, sym->strpos);
+         WRITELONG(p, sym->value);
+         WRITELONG(p, sym->size);
+-        WRITESHORT(p, sym->type);       /* global non-typed thing */
++        WRITECHAR(p, sym->type);       /* global non-typed thing */
++        WRITECHAR(p, sym->other);
+         WRITESHORT(p, sym->section);
+         saa_wbytes(s, entry, 16L);
+         *len += 16;
diff --git a/nios2-5.1.patch b/nios2-5.1.patch
new file mode 100644 (file)
index 0000000..a1aafbe
--- /dev/null
@@ -0,0 +1,7235 @@
+the niosii-gnutools-src-5.1.tgz release from altera is missing a lot of
+core gcc files, this patch adds them back in
+
+--- ./gcc/gcc/config/nios2/crti.asm
++++ ./gcc/gcc/config/nios2/crti.asm
+@@ -0,0 +1,88 @@
++/*
++  Copyright (C) 2003 
++ by Jonah Graham (jgraham@altera.com)
++
++This file is free software; you can redistribute it and/or modify it
++under the terms of the GNU General Public License as published by the
++Free Software Foundation; either version 2, or (at your option) any
++later version.
++
++In addition to the permissions in the GNU General Public License, the
++Free Software Foundation gives you unlimited permission to link the
++compiled version of this file with other programs, and to distribute
++those programs without any restriction coming from the use of this
++file.  (The General Public License restrictions do apply in other
++respects; for example, they cover modification of the file, and
++distribution when not linked into another program.)
++
++This file is distributed in the hope that it will be useful, but
++WITHOUT ANY WARRANTY; without even the implied warranty of
++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++General Public License for more details.
++
++You should have received a copy of the GNU General Public License
++along with this program; see the file COPYING.  If not, write to
++the Free Software Foundation, 59 Temple Place - Suite 330,
++Boston, MA 02111-1307, USA.
++
++   As a special exception, if you link this library with files
++   compiled with GCC to produce an executable, this does not cause
++   the resulting executable to be covered by the GNU General Public License.
++   This exception does not however invalidate any other reasons why
++   the executable file might be covered by the GNU General Public License.
++
++
++This file just make a stack frame for the contents of the .fini and
++.init sections.  Users may put any desired instructions in those
++sections.
++
++
++While technically any code can be put in the init and fini sections
++most stuff will not work other than stuff which obeys the call frame
++and ABI. All the call-preserved registers are saved, the call clobbered
++registers should have been saved by the code calling init and fini.
++
++See crtstuff.c for an example of code that inserts itself in the 
++init and fini sections. 
++
++See crt0.s for the code that calls init and fini.
++*/
++
++      .file   "crti.asm"
++
++      .section        ".init"
++      .align 2
++      .global _init
++_init:
++      addi    sp, sp, -48
++      stw     ra, 44(sp)
++      stw     r23, 40(sp)
++      stw     r22, 36(sp)
++      stw     r21, 32(sp)
++      stw     r20, 28(sp)
++      stw     r19, 24(sp)
++      stw     r18, 20(sp)
++      stw     r17, 16(sp)
++      stw     r16, 12(sp)
++      stw     fp, 8(sp)
++      mov     fp, sp
++      
++      
++      .section        ".fini"
++      .align  2
++      .global _fini
++_fini:
++      addi    sp, sp, -48
++      stw     ra, 44(sp)
++      stw     r23, 40(sp)
++      stw     r22, 36(sp)
++      stw     r21, 32(sp)
++      stw     r20, 28(sp)
++      stw     r19, 24(sp)
++      stw     r18, 20(sp)
++      stw     r17, 16(sp)
++      stw     r16, 12(sp)
++      stw     fp, 8(sp)
++      mov     fp, sp
++      
++
+--- ./gcc/gcc/config/nios2/crtn.asm
++++ ./gcc/gcc/config/nios2/crtn.asm
+@@ -0,0 +1,70 @@
++/*
++  Copyright (C) 2003 
++ by Jonah Graham (jgraham@altera.com)
++
++This file is free software; you can redistribute it and/or modify it
++under the terms of the GNU General Public License as published by the
++Free Software Foundation; either version 2, or (at your option) any
++later version.
++
++In addition to the permissions in the GNU General Public License, the
++Free Software Foundation gives you unlimited permission to link the
++compiled version of this file with other programs, and to distribute
++those programs without any restriction coming from the use of this
++file.  (The General Public License restrictions do apply in other
++respects; for example, they cover modification of the file, and
++distribution when not linked into another program.)
++
++This file is distributed in the hope that it will be useful, but
++WITHOUT ANY WARRANTY; without even the implied warranty of
++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++General Public License for more details.
++
++You should have received a copy of the GNU General Public License
++along with this program; see the file COPYING.  If not, write to
++the Free Software Foundation, 59 Temple Place - Suite 330,
++Boston, MA 02111-1307, USA.
++
++   As a special exception, if you link this library with files
++   compiled with GCC to produce an executable, this does not cause
++   the resulting executable to be covered by the GNU General Public License.
++   This exception does not however invalidate any other reasons why
++   the executable file might be covered by the GNU General Public License.
++
++
++This file just makes sure that the .fini and .init sections do in
++fact return.  Users may put any desired instructions in those sections.
++This file is the last thing linked into any executable.
++*/    
++      .file   "crtn.asm"
++
++
++
++      .section        ".init"
++      ldw     ra, 44(sp)
++      ldw     r23, 40(sp)
++      ldw     r22, 36(sp)
++      ldw     r21, 32(sp)
++      ldw     r20, 28(sp)
++      ldw     r19, 24(sp)
++      ldw     r18, 20(sp)
++      ldw     r17, 16(sp)
++      ldw     r16, 12(sp)
++      ldw     fp, 8(sp)
++      addi    sp, sp, -48
++      ret
++      
++      .section        ".fini"
++      ldw     ra, 44(sp)
++      ldw     r23, 40(sp)
++      ldw     r22, 36(sp)
++      ldw     r21, 32(sp)
++      ldw     r20, 28(sp)
++      ldw     r19, 24(sp)
++      ldw     r18, 20(sp)
++      ldw     r17, 16(sp)
++      ldw     r16, 12(sp)
++      ldw     fp, 8(sp)
++      addi    sp, sp, -48
++      ret
++      
+--- ./gcc/gcc/config/nios2/lib2-divmod-hi.c
++++ ./gcc/gcc/config/nios2/lib2-divmod-hi.c
+@@ -0,0 +1,123 @@
++
++/* We include auto-host.h here to get HAVE_GAS_HIDDEN.  This is
++   supposedly valid even though this is a "target" file.  */
++#include "auto-host.h"
++
++
++#include "tconfig.h"
++#include "tsystem.h"
++#include "coretypes.h"
++#include "tm.h"
++
++
++/* Don't use `fancy_abort' here even if config.h says to use it.  */
++#ifdef abort
++#undef abort
++#endif
++
++
++#ifdef HAVE_GAS_HIDDEN
++#define ATTRIBUTE_HIDDEN  __attribute__ ((__visibility__ ("hidden")))
++#else
++#define ATTRIBUTE_HIDDEN
++#endif
++
++#include "libgcc2.h"
++
++extern HItype __modhi3 (HItype, HItype);
++extern HItype __divhi3 (HItype, HItype);
++extern HItype __umodhi3 (HItype, HItype);
++extern HItype __udivhi3 (HItype, HItype);
++
++static UHItype udivmodhi4(UHItype, UHItype, word_type);
++
++static UHItype
++udivmodhi4(UHItype num, UHItype den, word_type modwanted)
++{
++  UHItype bit = 1;
++  UHItype res = 0;
++
++  while (den < num && bit && !(den & (1L<<15)))
++    {
++      den <<=1;
++      bit <<=1;
++    }
++  while (bit)
++    {
++      if (num >= den)
++      {
++        num -= den;
++        res |= bit;
++      }
++      bit >>=1;
++      den >>=1;
++    }
++  if (modwanted) return num;
++  return res;
++}
++
++
++HItype
++__divhi3 (HItype a, HItype b)
++{
++  word_type neg = 0;
++  HItype res;
++
++  if (a < 0)
++    {
++      a = -a;
++      neg = !neg;
++    }
++
++  if (b < 0)
++    {
++      b = -b;
++      neg = !neg;
++    }
++
++  res = udivmodhi4 (a, b, 0);
++
++  if (neg)
++    res = -res;
++
++  return res;
++}
++
++
++HItype
++__modhi3 (HItype a, HItype b)
++{
++  word_type neg = 0;
++  HItype res;
++
++  if (a < 0)
++    {
++      a = -a;
++      neg = 1;
++    }
++
++  if (b < 0)
++    b = -b;
++
++  res = udivmodhi4 (a, b, 1);
++
++  if (neg)
++    res = -res;
++
++  return res;
++}
++
++
++HItype
++__udivhi3 (HItype a, HItype b)
++{
++  return udivmodhi4 (a, b, 0);
++}
++
++
++HItype
++__umodhi3 (HItype a, HItype b)
++{
++  return udivmodhi4 (a, b, 1);
++}
++
+--- ./gcc/gcc/config/nios2/lib2-divmod.c
++++ ./gcc/gcc/config/nios2/lib2-divmod.c
+@@ -0,0 +1,126 @@
++
++/* We include auto-host.h here to get HAVE_GAS_HIDDEN.  This is
++   supposedly valid even though this is a "target" file.  */
++#include "auto-host.h"
++
++
++#include "tconfig.h"
++#include "tsystem.h"
++#include "coretypes.h"
++#include "tm.h"
++
++
++/* Don't use `fancy_abort' here even if config.h says to use it.  */
++#ifdef abort
++#undef abort
++#endif
++
++
++#ifdef HAVE_GAS_HIDDEN
++#define ATTRIBUTE_HIDDEN  __attribute__ ((__visibility__ ("hidden")))
++#else
++#define ATTRIBUTE_HIDDEN
++#endif
++
++#include "libgcc2.h"
++
++extern SItype __modsi3 (SItype, SItype);
++extern SItype __divsi3 (SItype, SItype);
++extern SItype __umodsi3 (SItype, SItype);
++extern SItype __udivsi3 (SItype, SItype);
++
++static USItype udivmodsi4(USItype, USItype, word_type);
++
++/* 16-bit SI divide and modulo as used in NIOS */
++
++
++static USItype
++udivmodsi4(USItype num, USItype den, word_type modwanted)
++{
++  USItype bit = 1;
++  USItype res = 0;
++
++  while (den < num && bit && !(den & (1L<<31)))
++    {
++      den <<=1;
++      bit <<=1;
++    }
++  while (bit)
++    {
++      if (num >= den)
++      {
++        num -= den;
++        res |= bit;
++      }
++      bit >>=1;
++      den >>=1;
++    }
++  if (modwanted) return num;
++  return res;
++}
++
++
++SItype
++__divsi3 (SItype a, SItype b)
++{
++  word_type neg = 0;
++  SItype res;
++
++  if (a < 0)
++    {
++      a = -a;
++      neg = !neg;
++    }
++
++  if (b < 0)
++    {
++      b = -b;
++      neg = !neg;
++    }
++
++  res = udivmodsi4 (a, b, 0);
++
++  if (neg)
++    res = -res;
++
++  return res;
++}
++
++
++SItype
++__modsi3 (SItype a, SItype b)
++{
++  word_type neg = 0;
++  SItype res;
++
++  if (a < 0)
++    {
++      a = -a;
++      neg = 1;
++    }
++
++  if (b < 0)
++    b = -b;
++
++  res = udivmodsi4 (a, b, 1);
++
++  if (neg)
++    res = -res;
++
++  return res;
++}
++
++
++SItype
++__udivsi3 (SItype a, SItype b)
++{
++  return udivmodsi4 (a, b, 0);
++}
++
++
++SItype
++__umodsi3 (SItype a, SItype b)
++{
++  return udivmodsi4 (a, b, 1);
++}
++
+--- ./gcc/gcc/config/nios2/lib2-divtable.c
++++ ./gcc/gcc/config/nios2/lib2-divtable.c
+@@ -0,0 +1,46 @@
++
++/* We include auto-host.h here to get HAVE_GAS_HIDDEN.  This is
++   supposedly valid even though this is a "target" file.  */
++#include "auto-host.h"
++
++
++#include "tconfig.h"
++#include "tsystem.h"
++#include "coretypes.h"
++#include "tm.h"
++
++
++/* Don't use `fancy_abort' here even if config.h says to use it.  */
++#ifdef abort
++#undef abort
++#endif
++
++
++#ifdef HAVE_GAS_HIDDEN
++#define ATTRIBUTE_HIDDEN  __attribute__ ((__visibility__ ("hidden")))
++#else
++#define ATTRIBUTE_HIDDEN
++#endif
++
++#include "libgcc2.h"
++
++UQItype __divsi3_table[] =
++{
++  0, 0/1, 0/2, 0/3, 0/4, 0/5, 0/6, 0/7, 0/8, 0/9, 0/10, 0/11, 0/12, 0/13, 0/14, 0/15,
++  0, 1/1, 1/2, 1/3, 1/4, 1/5, 1/6, 1/7, 1/8, 1/9, 1/10, 1/11, 1/12, 1/13, 1/14, 1/15,
++  0, 2/1, 2/2, 2/3, 2/4, 2/5, 2/6, 2/7, 2/8, 2/9, 2/10, 2/11, 2/12, 2/13, 2/14, 2/15,
++  0, 3/1, 3/2, 3/3, 3/4, 3/5, 3/6, 3/7, 3/8, 3/9, 3/10, 3/11, 3/12, 3/13, 3/14, 3/15,
++  0, 4/1, 4/2, 4/3, 4/4, 4/5, 4/6, 4/7, 4/8, 4/9, 4/10, 4/11, 4/12, 4/13, 4/14, 4/15,
++  0, 5/1, 5/2, 5/3, 5/4, 5/5, 5/6, 5/7, 5/8, 5/9, 5/10, 5/11, 5/12, 5/13, 5/14, 5/15,
++  0, 6/1, 6/2, 6/3, 6/4, 6/5, 6/6, 6/7, 6/8, 6/9, 6/10, 6/11, 6/12, 6/13, 6/14, 6/15,
++  0, 7/1, 7/2, 7/3, 7/4, 7/5, 7/6, 7/7, 7/8, 7/9, 7/10, 7/11, 7/12, 7/13, 7/14, 7/15,
++  0, 8/1, 8/2, 8/3, 8/4, 8/5, 8/6, 8/7, 8/8, 8/9, 8/10, 8/11, 8/12, 8/13, 8/14, 8/15,
++  0, 9/1, 9/2, 9/3, 9/4, 9/5, 9/6, 9/7, 9/8, 9/9, 9/10, 9/11, 9/12, 9/13, 9/14, 9/15,
++  0, 10/1, 10/2, 10/3, 10/4, 10/5, 10/6, 10/7, 10/8, 10/9, 10/10, 10/11, 10/12, 10/13, 10/14, 10/15,
++  0, 11/1, 11/2, 11/3, 11/4, 11/5, 11/6, 11/7, 11/8, 11/9, 11/10, 11/11, 11/12, 11/13, 11/14, 11/15,
++  0, 12/1, 12/2, 12/3, 12/4, 12/5, 12/6, 12/7, 12/8, 12/9, 12/10, 12/11, 12/12, 12/13, 12/14, 12/15,
++  0, 13/1, 13/2, 13/3, 13/4, 13/5, 13/6, 13/7, 13/8, 13/9, 13/10, 13/11, 13/12, 13/13, 13/14, 13/15,
++  0, 14/1, 14/2, 14/3, 14/4, 14/5, 14/6, 14/7, 14/8, 14/9, 14/10, 14/11, 14/12, 14/13, 14/14, 14/15,
++  0, 15/1, 15/2, 15/3, 15/4, 15/5, 15/6, 15/7, 15/8, 15/9, 15/10, 15/11, 15/12, 15/13, 15/14, 15/15,
++};
++
+--- ./gcc/gcc/config/nios2/lib2-mul.c
++++ ./gcc/gcc/config/nios2/lib2-mul.c
+@@ -0,0 +1,103 @@
++/* while we are debugging (ie compile outside of gcc build) 
++   disable gcc specific headers */
++#ifndef DEBUG_MULSI3
++
++
++/* We include auto-host.h here to get HAVE_GAS_HIDDEN.  This is
++   supposedly valid even though this is a "target" file.  */
++#include "auto-host.h"
++
++
++#include "tconfig.h"
++#include "tsystem.h"
++#include "coretypes.h"
++#include "tm.h"
++
++
++/* Don't use `fancy_abort' here even if config.h says to use it.  */
++#ifdef abort
++#undef abort
++#endif
++
++
++#ifdef HAVE_GAS_HIDDEN
++#define ATTRIBUTE_HIDDEN  __attribute__ ((__visibility__ ("hidden")))
++#else
++#define ATTRIBUTE_HIDDEN
++#endif
++
++#include "libgcc2.h"
++
++#else
++#define SItype int
++#define USItype unsigned int
++#endif
++
++
++extern SItype __mulsi3 (SItype, SItype);
++
++SItype
++__mulsi3 (SItype a, SItype b)
++{
++  SItype res = 0;
++  USItype cnt = a;
++  
++  while (cnt)
++    {
++      if (cnt & 1)
++        {
++        res += b;       
++      }
++      b <<= 1;
++      cnt >>= 1;
++    }
++    
++  return res;
++}
++/*
++TODO: Choose best alternative implementation.
++
++SItype
++__divsi3 (SItype a, SItype b)
++{
++  SItype res = 0;
++  USItype cnt = 0;
++  
++  while (cnt < 32)
++    {
++      if (a & (1L << cnt))
++        {
++        res += b;       
++      }
++      b <<= 1;
++      cnt++;
++    }
++    
++  return res;
++}
++*/
++
++
++#ifdef DEBUG_MULSI3
++
++int
++main ()
++{
++  int i, j;
++  int error = 0;
++  
++  for (i = -1000; i < 1000; i++)
++    for (j = -1000; j < 1000; j++)
++      {
++      int expect = i * j;
++      int actual = A__divsi3 (i, j);
++      if (expect != actual)
++        {
++          printf ("error: %d * %d = %d not %d\n", i, j, expect, actual);
++          error = 1;
++        }
++      }
++
++  return error;
++}
++#endif
+--- ./gcc/gcc/config/nios2/nios2-dp-bit.c
++++ ./gcc/gcc/config/nios2/nios2-dp-bit.c
+@@ -0,0 +1,1652 @@
++
++/* This is a software floating point library which can be used
++   for targets without hardware floating point. 
++   Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004
++   Free Software Foundation, Inc.
++
++This file is free software; you can redistribute it and/or modify it
++under the terms of the GNU General Public License as published by the
++Free Software Foundation; either version 2, or (at your option) any
++later version.
++
++In addition to the permissions in the GNU General Public License, the
++Free Software Foundation gives you unlimited permission to link the
++compiled version of this file with other programs, and to distribute
++those programs without any restriction coming from the use of this
++file.  (The General Public License restrictions do apply in other
++respects; for example, they cover modification of the file, and
++distribution when not linked into another program.)
++
++This file is distributed in the hope that it will be useful, but
++WITHOUT ANY WARRANTY; without even the implied warranty of
++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++General Public License for more details.
++
++You should have received a copy of the GNU General Public License
++along with this program; see the file COPYING.  If not, write to
++the Free Software Foundation, 59 Temple Place - Suite 330,
++Boston, MA 02111-1307, USA.  */
++
++/* As a special exception, if you link this library with other files,
++   some of which are compiled with GCC, to produce an executable,
++   this library does not by itself cause the resulting executable
++   to be covered by the GNU General Public License.
++   This exception does not however invalidate any other reasons why
++   the executable file might be covered by the GNU General Public License.  */
++
++/* This implements IEEE 754 format arithmetic, but does not provide a
++   mechanism for setting the rounding mode, or for generating or handling
++   exceptions.
++
++   The original code by Steve Chamberlain, hacked by Mark Eichin and Jim
++   Wilson, all of Cygnus Support.  */
++
++/* The intended way to use this file is to make two copies, add `#define FLOAT'
++   to one copy, then compile both copies and add them to libgcc.a.  */
++
++#include "tconfig.h"
++#include "coretypes.h"
++#include "tm.h"
++#include "config/fp-bit.h"
++
++/* The following macros can be defined to change the behavior of this file:
++   FLOAT: Implement a `float', aka SFmode, fp library.  If this is not
++     defined, then this file implements a `double', aka DFmode, fp library.
++   FLOAT_ONLY: Used with FLOAT, to implement a `float' only library, i.e.
++     don't include float->double conversion which requires the double library.
++     This is useful only for machines which can't support doubles, e.g. some
++     8-bit processors.
++   CMPtype: Specify the type that floating point compares should return.
++     This defaults to SItype, aka int.
++   US_SOFTWARE_GOFAST: This makes all entry points use the same names as the
++     US Software goFast library.
++   _DEBUG_BITFLOAT: This makes debugging the code a little easier, by adding
++     two integers to the FLO_union_type.
++   NO_DENORMALS: Disable handling of denormals.
++   NO_NANS: Disable nan and infinity handling
++   SMALL_MACHINE: Useful when operations on QIs and HIs are faster
++     than on an SI */
++
++/* We don't currently support extended floats (long doubles) on machines
++   without hardware to deal with them.
++
++   These stubs are just to keep the linker from complaining about unresolved
++   references which can be pulled in from libio & libstdc++, even if the
++   user isn't using long doubles.  However, they may generate an unresolved
++   external to abort if abort is not used by the function, and the stubs
++   are referenced from within libc, since libgcc goes before and after the
++   system library.  */
++
++#ifdef DECLARE_LIBRARY_RENAMES
++  DECLARE_LIBRARY_RENAMES
++#endif
++
++#ifdef EXTENDED_FLOAT_STUBS
++extern void abort (void);
++void __extendsfxf2 (void) { abort(); }
++void __extenddfxf2 (void) { abort(); }
++void __truncxfdf2 (void) { abort(); }
++void __truncxfsf2 (void) { abort(); }
++void __fixxfsi (void) { abort(); }
++void __floatsixf (void) { abort(); }
++void __addxf3 (void) { abort(); }
++void __subxf3 (void) { abort(); }
++void __mulxf3 (void) { abort(); }
++void __divxf3 (void) { abort(); }
++void __negxf2 (void) { abort(); }
++void __eqxf2 (void) { abort(); }
++void __nexf2 (void) { abort(); }
++void __gtxf2 (void) { abort(); }
++void __gexf2 (void) { abort(); }
++void __lexf2 (void) { abort(); }
++void __ltxf2 (void) { abort(); }
++
++void __extendsftf2 (void) { abort(); }
++void __extenddftf2 (void) { abort(); }
++void __trunctfdf2 (void) { abort(); }
++void __trunctfsf2 (void) { abort(); }
++void __fixtfsi (void) { abort(); }
++void __floatsitf (void) { abort(); }
++void __addtf3 (void) { abort(); }
++void __subtf3 (void) { abort(); }
++void __multf3 (void) { abort(); }
++void __divtf3 (void) { abort(); }
++void __negtf2 (void) { abort(); }
++void __eqtf2 (void) { abort(); }
++void __netf2 (void) { abort(); }
++void __gttf2 (void) { abort(); }
++void __getf2 (void) { abort(); }
++void __letf2 (void) { abort(); }
++void __lttf2 (void) { abort(); }
++#else /* !EXTENDED_FLOAT_STUBS, rest of file */
++
++/* IEEE "special" number predicates */
++
++#ifdef NO_NANS
++
++#define nan() 0
++#define isnan(x) 0
++#define isinf(x) 0
++#else
++
++#if   defined L_thenan_sf
++const fp_number_type __thenan_sf = { CLASS_SNAN, 0, 0, {(fractype) 0} };
++#elif defined L_thenan_df
++const fp_number_type __thenan_df = { CLASS_SNAN, 0, 0, {(fractype) 0} };
++#elif defined L_thenan_tf
++const fp_number_type __thenan_tf = { CLASS_SNAN, 0, 0, {(fractype) 0} };
++#elif defined TFLOAT
++extern const fp_number_type __thenan_tf;
++#elif defined FLOAT
++extern const fp_number_type __thenan_sf;
++#else
++extern const fp_number_type __thenan_df;
++#endif
++
++INLINE
++static fp_number_type *
++nan (void)
++{
++  /* Discard the const qualifier...  */
++#ifdef TFLOAT
++  return (fp_number_type *) (& __thenan_tf);
++#elif defined FLOAT  
++  return (fp_number_type *) (& __thenan_sf);
++#else
++  return (fp_number_type *) (& __thenan_df);
++#endif
++}
++
++INLINE
++static int
++isnan ( fp_number_type *  x)
++{
++  return x->class == CLASS_SNAN || x->class == CLASS_QNAN;
++}
++
++INLINE
++static int
++isinf ( fp_number_type *  x)
++{
++  return x->class == CLASS_INFINITY;
++}
++
++#endif /* NO_NANS */
++
++INLINE
++static int
++iszero ( fp_number_type *  x)
++{
++  return x->class == CLASS_ZERO;
++}
++
++INLINE 
++static void
++flip_sign ( fp_number_type *  x)
++{
++  x->sign = !x->sign;
++}
++
++extern FLO_type pack_d ( fp_number_type * );
++
++#if defined(L_pack_df) || defined(L_pack_sf) || defined(L_pack_tf)
++FLO_type
++pack_d ( fp_number_type *  src)
++{
++  FLO_union_type dst;
++  fractype fraction = src->fraction.ll;       /* wasn't unsigned before? */
++  int sign = src->sign;
++  int exp = 0;
++
++  if (LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && (isnan (src) || isinf (src)))
++    {
++      /* We can't represent these values accurately.  By using the
++       largest possible magnitude, we guarantee that the conversion
++       of infinity is at least as big as any finite number.  */
++      exp = EXPMAX;
++      fraction = ((fractype) 1 << FRACBITS) - 1;
++    }
++  else if (isnan (src))
++    {
++      exp = EXPMAX;
++      if (src->class == CLASS_QNAN || 1)
++      {
++#ifdef QUIET_NAN_NEGATED
++        fraction |= QUIET_NAN - 1;
++#else
++        fraction |= QUIET_NAN;
++#endif
++      }
++    }
++  else if (isinf (src))
++    {
++      exp = EXPMAX;
++      fraction = 0;
++    }
++  else if (iszero (src))
++    {
++      exp = 0;
++      fraction = 0;
++    }
++  else if (fraction == 0)
++    {
++      exp = 0;
++    }
++  else
++    {
++      if (src->normal_exp < NORMAL_EXPMIN)
++      {
++#ifdef NO_DENORMALS
++        /* Go straight to a zero representation if denormals are not
++           supported.  The denormal handling would be harmless but
++           isn't unnecessary.  */
++        exp = 0;
++        fraction = 0;
++#else /* NO_DENORMALS */
++        /* This number's exponent is too low to fit into the bits
++           available in the number, so we'll store 0 in the exponent and
++           shift the fraction to the right to make up for it.  */
++
++        int shift = NORMAL_EXPMIN - src->normal_exp;
++
++        exp = 0;
++
++        if (shift > FRAC_NBITS - NGARDS)
++          {
++            /* No point shifting, since it's more that 64 out.  */
++            fraction = 0;
++          }
++        else
++          {
++            int lowbit = (fraction & (((fractype)1 << shift) - 1)) ? 1 : 0;
++            fraction = (fraction >> shift) | lowbit;
++          }
++        if ((fraction & GARDMASK) == GARDMSB)
++          {
++            if ((fraction & (1 << NGARDS)))
++              fraction += GARDROUND + 1;
++          }
++        else
++          {
++            /* Add to the guards to round up.  */
++            fraction += GARDROUND;
++          }
++        /* Perhaps the rounding means we now need to change the
++             exponent, because the fraction is no longer denormal.  */
++        if (fraction >= IMPLICIT_1)
++          {
++            exp += 1;
++          }
++        fraction >>= NGARDS;
++#endif /* NO_DENORMALS */
++      }
++      else if (!LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS)
++             && src->normal_exp > EXPBIAS)
++      {
++        exp = EXPMAX;
++        fraction = 0;
++      }
++      else
++      {
++        exp = src->normal_exp + EXPBIAS;
++        if (!ROUND_TOWARDS_ZERO)
++          {
++            /* IF the gard bits are the all zero, but the first, then we're
++               half way between two numbers, choose the one which makes the
++               lsb of the answer 0.  */
++            if ((fraction & GARDMASK) == GARDMSB)
++              {
++                if (fraction & (1 << NGARDS))
++                  fraction += GARDROUND + 1;
++              }
++            else
++              {
++                /* Add a one to the guards to round up */
++                fraction += GARDROUND;
++              }
++            if (fraction >= IMPLICIT_2)
++              {
++                fraction >>= 1;
++                exp += 1;
++              }
++          }
++        fraction >>= NGARDS;
++
++        if (LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && exp > EXPMAX)
++          {
++            /* Saturate on overflow.  */
++            exp = EXPMAX;
++            fraction = ((fractype) 1 << FRACBITS) - 1;
++          }
++      }
++    }
++
++  /* We previously used bitfields to store the number, but this doesn't
++     handle little/big endian systems conveniently, so use shifts and
++     masks */
++#ifdef FLOAT_BIT_ORDER_MISMATCH
++  dst.bits.fraction = fraction;
++  dst.bits.exp = exp;
++  dst.bits.sign = sign;
++#else
++# if defined TFLOAT && defined HALFFRACBITS
++ {
++   halffractype high, low, unity;
++   int lowsign, lowexp;
++
++   unity = (halffractype) 1 << HALFFRACBITS;
++
++   /* Set HIGH to the high double's significand, masking out the implicit 1.
++      Set LOW to the low double's full significand.  */
++   high = (fraction >> (FRACBITS - HALFFRACBITS)) & (unity - 1);
++   low = fraction & (unity * 2 - 1);
++
++   /* Get the initial sign and exponent of the low double.  */
++   lowexp = exp - HALFFRACBITS - 1;
++   lowsign = sign;
++
++   /* HIGH should be rounded like a normal double, making |LOW| <=
++      0.5 ULP of HIGH.  Assume round-to-nearest.  */
++   if (exp < EXPMAX)
++     if (low > unity || (low == unity && (high & 1) == 1))
++       {
++       /* Round HIGH up and adjust LOW to match.  */
++       high++;
++       if (high == unity)
++         {
++           /* May make it infinite, but that's OK.  */
++           high = 0;
++           exp++;
++         }
++       low = unity * 2 - low;
++       lowsign ^= 1;
++       }
++
++   high |= (halffractype) exp << HALFFRACBITS;
++   high |= (halffractype) sign << (HALFFRACBITS + EXPBITS);
++
++   if (exp == EXPMAX || exp == 0 || low == 0)
++     low = 0;
++   else
++     {
++       while (lowexp > 0 && low < unity)
++       {
++         low <<= 1;
++         lowexp--;
++       }
++
++       if (lowexp <= 0)
++       {
++         halffractype roundmsb, round;
++         int shift;
++
++         shift = 1 - lowexp;
++         roundmsb = (1 << (shift - 1));
++         round = low & ((roundmsb << 1) - 1);
++
++         low >>= shift;
++         lowexp = 0;
++
++         if (round > roundmsb || (round == roundmsb && (low & 1) == 1))
++           {
++             low++;
++             if (low == unity)
++               /* LOW rounds up to the smallest normal number.  */
++               lowexp++;
++           }
++       }
++
++       low &= unity - 1;
++       low |= (halffractype) lowexp << HALFFRACBITS;
++       low |= (halffractype) lowsign << (HALFFRACBITS + EXPBITS);
++     }
++   dst.value_raw = ((fractype) high << HALFSHIFT) | low;
++ }
++# else
++  dst.value_raw = fraction & ((((fractype)1) << FRACBITS) - (fractype)1);
++  dst.value_raw |= ((fractype) (exp & ((1 << EXPBITS) - 1))) << FRACBITS;
++  dst.value_raw |= ((fractype) (sign & 1)) << (FRACBITS | EXPBITS);
++# endif
++#endif
++
++#if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
++#ifdef TFLOAT
++  {
++    qrtrfractype tmp1 = dst.words[0];
++    qrtrfractype tmp2 = dst.words[1];
++    dst.words[0] = dst.words[3];
++    dst.words[1] = dst.words[2];
++    dst.words[2] = tmp2;
++    dst.words[3] = tmp1;
++  }
++#else
++  {
++    halffractype tmp = dst.words[0];
++    dst.words[0] = dst.words[1];
++    dst.words[1] = tmp;
++  }
++#endif
++#endif
++
++  return dst.value;
++}
++#endif
++
++#if defined(L_unpack_df) || defined(L_unpack_sf) || defined(L_unpack_tf)
++void
++unpack_d (FLO_union_type * src, fp_number_type * dst)
++{
++  /* We previously used bitfields to store the number, but this doesn't
++     handle little/big endian systems conveniently, so use shifts and
++     masks */
++  fractype fraction;
++  int exp;
++  int sign;
++
++#if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
++  FLO_union_type swapped;
++
++#ifdef TFLOAT
++  swapped.words[0] = src->words[3];
++  swapped.words[1] = src->words[2];
++  swapped.words[2] = src->words[1];
++  swapped.words[3] = src->words[0];
++#else
++  swapped.words[0] = src->words[1];
++  swapped.words[1] = src->words[0];
++#endif
++  src = &swapped;
++#endif
++  
++#ifdef FLOAT_BIT_ORDER_MISMATCH
++  fraction = src->bits.fraction;
++  exp = src->bits.exp;
++  sign = src->bits.sign;
++#else
++# if defined TFLOAT && defined HALFFRACBITS
++ {
++   halffractype high, low;
++   
++   high = src->value_raw >> HALFSHIFT;
++   low = src->value_raw & (((fractype)1 << HALFSHIFT) - 1);
++
++   fraction = high & ((((fractype)1) << HALFFRACBITS) - 1);
++   fraction <<= FRACBITS - HALFFRACBITS;
++   exp = ((int)(high >> HALFFRACBITS)) & ((1 << EXPBITS) - 1);
++   sign = ((int)(high >> (((HALFFRACBITS + EXPBITS))))) & 1;
++
++   if (exp != EXPMAX && exp != 0 && low != 0)
++     {
++       int lowexp = ((int)(low >> HALFFRACBITS)) & ((1 << EXPBITS) - 1);
++       int lowsign = ((int)(low >> (((HALFFRACBITS + EXPBITS))))) & 1;
++       int shift;
++       fractype xlow;
++
++       xlow = low & ((((fractype)1) << HALFFRACBITS) - 1);
++       if (lowexp)
++       xlow |= (((halffractype)1) << HALFFRACBITS);
++       else
++       lowexp = 1;
++       shift = (FRACBITS - HALFFRACBITS) - (exp - lowexp);
++       if (shift > 0)
++       xlow <<= shift;
++       else if (shift < 0)
++       xlow >>= -shift;
++       if (sign == lowsign)
++       fraction += xlow;
++       else if (fraction >= xlow)
++       fraction -= xlow;
++       else
++       {
++         /* The high part is a power of two but the full number is lower.
++            This code will leave the implicit 1 in FRACTION, but we'd
++            have added that below anyway.  */
++         fraction = (((fractype) 1 << FRACBITS) - xlow) << 1;
++         exp--;
++       }
++     }
++ }
++# else
++  fraction = src->value_raw & ((((fractype)1) << FRACBITS) - 1);
++  exp = ((int)(src->value_raw >> FRACBITS)) & ((1 << EXPBITS) - 1);
++  sign = ((int)(src->value_raw >> (FRACBITS + EXPBITS))) & 1;
++# endif
++#endif
++
++  dst->sign = sign;
++  if (exp == 0)
++    {
++      /* Hmm.  Looks like 0 */
++      if (fraction == 0
++#ifdef NO_DENORMALS
++        || 1
++#endif
++        )
++      {
++        /* tastes like zero */
++        dst->class = CLASS_ZERO;
++      }
++      else
++      {
++        /* Zero exponent with nonzero fraction - it's denormalized,
++           so there isn't a leading implicit one - we'll shift it so
++           it gets one.  */
++        dst->normal_exp = exp - EXPBIAS + 1;
++        fraction <<= NGARDS;
++
++        dst->class = CLASS_NUMBER;
++#if 1
++        while (fraction < IMPLICIT_1)
++          {
++            fraction <<= 1;
++            dst->normal_exp--;
++          }
++#endif
++        dst->fraction.ll = fraction;
++      }
++    }
++  else if (!LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && exp == EXPMAX)
++    {
++      /* Huge exponent*/
++      if (fraction == 0)
++      {
++        /* Attached to a zero fraction - means infinity */
++        dst->class = CLASS_INFINITY;
++      }
++      else
++      {
++        /* Nonzero fraction, means nan */
++#ifdef QUIET_NAN_NEGATED
++        if ((fraction & QUIET_NAN) == 0)
++#else
++        if (fraction & QUIET_NAN)
++#endif
++          {
++            dst->class = CLASS_QNAN;
++          }
++        else
++          {
++            dst->class = CLASS_SNAN;
++          }
++        /* Keep the fraction part as the nan number */
++        dst->fraction.ll = fraction;
++      }
++    }
++  else
++    {
++      /* Nothing strange about this number */
++      dst->normal_exp = exp - EXPBIAS;
++      dst->class = CLASS_NUMBER;
++      dst->fraction.ll = (fraction << NGARDS) | IMPLICIT_1;
++    }
++}
++#endif /* L_unpack_df || L_unpack_sf */
++
++#if defined(L_addsub_sf) || defined(L_addsub_df) || defined(L_addsub_tf)
++static fp_number_type *
++_fpadd_parts (fp_number_type * a,
++            fp_number_type * b,
++            fp_number_type * tmp)
++{
++  intfrac tfraction;
++
++  /* Put commonly used fields in local variables.  */
++  int a_normal_exp;
++  int b_normal_exp;
++  fractype a_fraction;
++  fractype b_fraction;
++
++  if (isnan (a))
++    {
++      return a;
++    }
++  if (isnan (b))
++    {
++      return b;
++    }
++  if (isinf (a))
++    {
++      /* Adding infinities with opposite signs yields a NaN.  */
++      if (isinf (b) && a->sign != b->sign)
++      return nan ();
++      return a;
++    }
++  if (isinf (b))
++    {
++      return b;
++    }
++  if (iszero (b))
++    {
++      if (iszero (a))
++      {
++        *tmp = *a;
++        tmp->sign = a->sign & b->sign;
++        return tmp;
++      }
++      return a;
++    }
++  if (iszero (a))
++    {
++      return b;
++    }
++
++  /* Got two numbers. shift the smaller and increment the exponent till
++     they're the same */
++  {
++    int diff;
++
++    a_normal_exp = a->normal_exp;
++    b_normal_exp = b->normal_exp;
++    a_fraction = a->fraction.ll;
++    b_fraction = b->fraction.ll;
++
++    diff = a_normal_exp - b_normal_exp;
++
++    if (diff < 0)
++      diff = -diff;
++    if (diff < FRAC_NBITS)
++      {
++      /* ??? This does shifts one bit at a time.  Optimize.  */
++      while (a_normal_exp > b_normal_exp)
++        {
++          b_normal_exp++;
++          LSHIFT (b_fraction);
++        }
++      while (b_normal_exp > a_normal_exp)
++        {
++          a_normal_exp++;
++          LSHIFT (a_fraction);
++        }
++      }
++    else
++      {
++      /* Somethings's up.. choose the biggest */
++      if (a_normal_exp > b_normal_exp)
++        {
++          b_normal_exp = a_normal_exp;
++          b_fraction = 0;
++        }
++      else
++        {
++          a_normal_exp = b_normal_exp;
++          a_fraction = 0;
++        }
++      }
++  }
++
++  if (a->sign != b->sign)
++    {
++      if (a->sign)
++      {
++        tfraction = -a_fraction + b_fraction;
++      }
++      else
++      {
++        tfraction = a_fraction - b_fraction;
++      }
++      if (tfraction >= 0)
++      {
++        tmp->sign = 0;
++        tmp->normal_exp = a_normal_exp;
++        tmp->fraction.ll = tfraction;
++      }
++      else
++      {
++        tmp->sign = 1;
++        tmp->normal_exp = a_normal_exp;
++        tmp->fraction.ll = -tfraction;
++      }
++      /* and renormalize it */
++
++      while (tmp->fraction.ll < IMPLICIT_1 && tmp->fraction.ll)
++      {
++        tmp->fraction.ll <<= 1;
++        tmp->normal_exp--;
++      }
++    }
++  else
++    {
++      tmp->sign = a->sign;
++      tmp->normal_exp = a_normal_exp;
++      tmp->fraction.ll = a_fraction + b_fraction;
++    }
++  tmp->class = CLASS_NUMBER;
++  /* Now the fraction is added, we have to shift down to renormalize the
++     number */
++
++  if (tmp->fraction.ll >= IMPLICIT_2)
++    {
++      LSHIFT (tmp->fraction.ll);
++      tmp->normal_exp++;
++    }
++  return tmp;
++
++}
++
++FLO_type
++add (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  fp_number_type tmp;
++  fp_number_type *res;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  res = _fpadd_parts (&a, &b, &tmp);
++
++  return pack_d (res);
++}
++
++FLO_type
++sub (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  fp_number_type tmp;
++  fp_number_type *res;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  b.sign ^= 1;
++
++  res = _fpadd_parts (&a, &b, &tmp);
++
++  return pack_d (res);
++}
++#endif /* L_addsub_sf || L_addsub_df */
++
++#if defined(L_mul_sf) || defined(L_mul_df) || defined(L_mul_tf)
++static inline __attribute__ ((__always_inline__)) fp_number_type *
++_fpmul_parts ( fp_number_type *  a,
++             fp_number_type *  b,
++             fp_number_type * tmp)
++{
++  fractype low = 0;
++  fractype high = 0;
++
++  if (isnan (a))
++    {
++      a->sign = a->sign != b->sign;
++      return a;
++    }
++  if (isnan (b))
++    {
++      b->sign = a->sign != b->sign;
++      return b;
++    }
++  if (isinf (a))
++    {
++      if (iszero (b))
++      return nan ();
++      a->sign = a->sign != b->sign;
++      return a;
++    }
++  if (isinf (b))
++    {
++      if (iszero (a))
++      {
++        return nan ();
++      }
++      b->sign = a->sign != b->sign;
++      return b;
++    }
++  if (iszero (a))
++    {
++      a->sign = a->sign != b->sign;
++      return a;
++    }
++  if (iszero (b))
++    {
++      b->sign = a->sign != b->sign;
++      return b;
++    }
++
++  /* Calculate the mantissa by multiplying both numbers to get a
++     twice-as-wide number.  */
++  {
++#if defined(NO_DI_MODE) || defined(TFLOAT)
++    {
++      fractype x = a->fraction.ll;
++      fractype ylow = b->fraction.ll;
++      fractype yhigh = 0;
++      int bit;
++
++      /* ??? This does multiplies one bit at a time.  Optimize.  */
++      for (bit = 0; bit < FRAC_NBITS; bit++)
++      {
++        int carry;
++
++        if (x & 1)
++          {
++            carry = (low += ylow) < ylow;
++            high += yhigh + carry;
++          }
++        yhigh <<= 1;
++        if (ylow & FRACHIGH)
++          {
++            yhigh |= 1;
++          }
++        ylow <<= 1;
++        x >>= 1;
++      }
++    }
++#elif defined(FLOAT) 
++    /* Multiplying two USIs to get a UDI, we're safe.  */
++    {
++      UDItype answer = (UDItype)a->fraction.ll * (UDItype)b->fraction.ll;
++      
++      high = answer >> BITS_PER_SI;
++      low = answer;
++    }
++#else
++    /* fractype is DImode, but we need the result to be twice as wide.
++       Assuming a widening multiply from DImode to TImode is not
++       available, build one by hand.  */
++    {
++      USItype nl = a->fraction.ll;
++      USItype nh = a->fraction.ll >> BITS_PER_SI;
++      USItype ml = b->fraction.ll;
++      USItype mh = b->fraction.ll >> BITS_PER_SI;
++      UDItype pp_ll = (UDItype) ml * nl;
++      UDItype pp_hl = (UDItype) mh * nl;
++      UDItype pp_lh = (UDItype) ml * nh;
++      UDItype pp_hh = (UDItype) mh * nh;
++      UDItype res2 = 0;
++      UDItype res0 = 0;
++      UDItype ps_hh__ = pp_hl + pp_lh;
++      if (ps_hh__ < pp_hl)
++      res2 += (UDItype)1 << BITS_PER_SI;
++      pp_hl = (UDItype)(USItype)ps_hh__ << BITS_PER_SI;
++      res0 = pp_ll + pp_hl;
++      if (res0 < pp_ll)
++      res2++;
++      res2 += (ps_hh__ >> BITS_PER_SI) + pp_hh;
++      high = res2;
++      low = res0;
++    }
++#endif
++  }
++
++  tmp->normal_exp = a->normal_exp + b->normal_exp
++    + FRAC_NBITS - (FRACBITS + NGARDS);
++  tmp->sign = a->sign != b->sign;
++  while (high >= IMPLICIT_2)
++    {
++      tmp->normal_exp++;
++      if (high & 1)
++      {
++        low >>= 1;
++        low |= FRACHIGH;
++      }
++      high >>= 1;
++    }
++  while (high < IMPLICIT_1)
++    {
++      tmp->normal_exp--;
++
++      high <<= 1;
++      if (low & FRACHIGH)
++      high |= 1;
++      low <<= 1;
++    }
++  /* rounding is tricky. if we only round if it won't make us round later.  */
++#if 0
++  if (low & FRACHIGH2)
++    {
++      if (((high & GARDMASK) != GARDMSB)
++        && (((high + 1) & GARDMASK) == GARDMSB))
++      {
++        /* don't round, it gets done again later.  */
++      }
++      else
++      {
++        high++;
++      }
++    }
++#endif
++  if (!ROUND_TOWARDS_ZERO && (high & GARDMASK) == GARDMSB)
++    {
++      if (high & (1 << NGARDS))
++      {
++        /* half way, so round to even */
++        high += GARDROUND + 1;
++      }
++      else if (low)
++      {
++        /* but we really weren't half way */
++        high += GARDROUND + 1;
++      }
++    }
++  tmp->fraction.ll = high;
++  tmp->class = CLASS_NUMBER;
++  return tmp;
++}
++
++FLO_type
++multiply (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  fp_number_type tmp;
++  fp_number_type *res;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  res = _fpmul_parts (&a, &b, &tmp);
++
++  return pack_d (res);
++}
++#endif /* L_mul_sf || L_mul_df */
++
++#if defined(L_div_sf) || defined(L_div_df) || defined(L_div_tf)
++static inline __attribute__ ((__always_inline__)) fp_number_type *
++_fpdiv_parts (fp_number_type * a,
++            fp_number_type * b)
++{
++  fractype bit;
++  fractype numerator;
++  fractype denominator;
++  fractype quotient;
++
++  if (isnan (a))
++    {
++      return a;
++    }
++  if (isnan (b))
++    {
++      return b;
++    }
++
++  a->sign = a->sign ^ b->sign;
++
++  if (isinf (a) || iszero (a))
++    {
++      if (a->class == b->class)
++      return nan ();
++      return a;
++    }
++
++  if (isinf (b))
++    {
++      a->fraction.ll = 0;
++      a->normal_exp = 0;
++      return a;
++    }
++  if (iszero (b))
++    {
++      a->class = CLASS_INFINITY;
++      return a;
++    }
++
++  /* Calculate the mantissa by multiplying both 64bit numbers to get a
++     128 bit number */
++  {
++    /* quotient =
++       ( numerator / denominator) * 2^(numerator exponent -  denominator exponent)
++     */
++
++    a->normal_exp = a->normal_exp - b->normal_exp;
++    numerator = a->fraction.ll;
++    denominator = b->fraction.ll;
++
++    if (numerator < denominator)
++      {
++      /* Fraction will be less than 1.0 */
++      numerator *= 2;
++      a->normal_exp--;
++      }
++    bit = IMPLICIT_1;
++    quotient = 0;
++    /* ??? Does divide one bit at a time.  Optimize.  */
++    while (bit)
++      {
++      if (numerator >= denominator)
++        {
++          quotient |= bit;
++          numerator -= denominator;
++        }
++      bit >>= 1;
++      numerator *= 2;
++      }
++
++    if (!ROUND_TOWARDS_ZERO && (quotient & GARDMASK) == GARDMSB)
++      {
++      if (quotient & (1 << NGARDS))
++        {
++          /* half way, so round to even */
++          quotient += GARDROUND + 1;
++        }
++      else if (numerator)
++        {
++          /* but we really weren't half way, more bits exist */
++          quotient += GARDROUND + 1;
++        }
++      }
++
++    a->fraction.ll = quotient;
++    return (a);
++  }
++}
++
++FLO_type
++divide (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  fp_number_type *res;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  res = _fpdiv_parts (&a, &b);
++
++  return pack_d (res);
++}
++#endif /* L_div_sf || L_div_df */
++
++#if defined(L_fpcmp_parts_sf) || defined(L_fpcmp_parts_df) \
++    || defined(L_fpcmp_parts_tf)
++/* according to the demo, fpcmp returns a comparison with 0... thus
++   a<b -> -1
++   a==b -> 0
++   a>b -> +1
++ */
++
++int
++__fpcmp_parts (fp_number_type * a, fp_number_type * b)
++{
++#if 0
++  /* either nan -> unordered. Must be checked outside of this routine.  */
++  if (isnan (a) && isnan (b))
++    {
++      return 1;                       /* still unordered! */
++    }
++#endif
++
++  if (isnan (a) || isnan (b))
++    {
++      return 1;                       /* how to indicate unordered compare? */
++    }
++  if (isinf (a) && isinf (b))
++    {
++      /* +inf > -inf, but +inf != +inf */
++      /* b    \a| +inf(0)| -inf(1)
++       ______\+--------+--------
++       +inf(0)| a==b(0)| a<b(-1)
++       -------+--------+--------
++       -inf(1)| a>b(1) | a==b(0)
++       -------+--------+--------
++       So since unordered must be nonzero, just line up the columns...
++       */
++      return b->sign - a->sign;
++    }
++  /* but not both...  */
++  if (isinf (a))
++    {
++      return a->sign ? -1 : 1;
++    }
++  if (isinf (b))
++    {
++      return b->sign ? 1 : -1;
++    }
++  if (iszero (a) && iszero (b))
++    {
++      return 0;
++    }
++  if (iszero (a))
++    {
++      return b->sign ? 1 : -1;
++    }
++  if (iszero (b))
++    {
++      return a->sign ? -1 : 1;
++    }
++  /* now both are "normal".  */
++  if (a->sign != b->sign)
++    {
++      /* opposite signs */
++      return a->sign ? -1 : 1;
++    }
++  /* same sign; exponents? */
++  if (a->normal_exp > b->normal_exp)
++    {
++      return a->sign ? -1 : 1;
++    }
++  if (a->normal_exp < b->normal_exp)
++    {
++      return a->sign ? 1 : -1;
++    }
++  /* same exponents; check size.  */
++  if (a->fraction.ll > b->fraction.ll)
++    {
++      return a->sign ? -1 : 1;
++    }
++  if (a->fraction.ll < b->fraction.ll)
++    {
++      return a->sign ? 1 : -1;
++    }
++  /* after all that, they're equal.  */
++  return 0;
++}
++#endif
++
++#if defined(L_compare_sf) || defined(L_compare_df) || defined(L_compoare_tf)
++CMPtype
++compare (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  return __fpcmp_parts (&a, &b);
++}
++#endif /* L_compare_sf || L_compare_df */
++
++#ifndef US_SOFTWARE_GOFAST
++
++/* These should be optimized for their specific tasks someday.  */
++
++#if defined(L_eq_sf) || defined(L_eq_df) || defined(L_eq_tf)
++CMPtype
++_eq_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return 1;                 /* false, truth == 0 */
++
++  return __fpcmp_parts (&a, &b) ;
++}
++#endif /* L_eq_sf || L_eq_df */
++
++#if defined(L_ne_sf) || defined(L_ne_df) || defined(L_ne_tf)
++CMPtype
++_ne_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return 1;                 /* true, truth != 0 */
++
++  return  __fpcmp_parts (&a, &b) ;
++}
++#endif /* L_ne_sf || L_ne_df */
++
++#if defined(L_gt_sf) || defined(L_gt_df) || defined(L_gt_tf)
++CMPtype
++_gt_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return -1;                        /* false, truth > 0 */
++
++  return __fpcmp_parts (&a, &b);
++}
++#endif /* L_gt_sf || L_gt_df */
++
++#if defined(L_ge_sf) || defined(L_ge_df) || defined(L_ge_tf)
++CMPtype
++_ge_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return -1;                        /* false, truth >= 0 */
++  return __fpcmp_parts (&a, &b) ;
++}
++#endif /* L_ge_sf || L_ge_df */
++
++#if defined(L_lt_sf) || defined(L_lt_df) || defined(L_lt_tf)
++CMPtype
++_lt_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return 1;                 /* false, truth < 0 */
++
++  return __fpcmp_parts (&a, &b);
++}
++#endif /* L_lt_sf || L_lt_df */
++
++#if defined(L_le_sf) || defined(L_le_df) || defined(L_le_tf)
++CMPtype
++_le_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return 1;                 /* false, truth <= 0 */
++
++  return __fpcmp_parts (&a, &b) ;
++}
++#endif /* L_le_sf || L_le_df */
++
++#endif /* ! US_SOFTWARE_GOFAST */
++
++#if defined(L_unord_sf) || defined(L_unord_df) || defined(L_unord_tf)
++CMPtype
++_unord_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  return (isnan (&a) || isnan (&b));
++}
++#endif /* L_unord_sf || L_unord_df */
++
++#if defined(L_si_to_sf) || defined(L_si_to_df) || defined(L_si_to_tf)
++FLO_type
++si_to_float (SItype arg_a)
++{
++  fp_number_type in;
++
++  in.class = CLASS_NUMBER;
++  in.sign = arg_a < 0;
++  if (!arg_a)
++    {
++      in.class = CLASS_ZERO;
++    }
++  else
++    {
++      in.normal_exp = FRACBITS + NGARDS;
++      if (in.sign) 
++      {
++        /* Special case for minint, since there is no +ve integer
++           representation for it */
++        if (arg_a == (- MAX_SI_INT - 1))
++          {
++            return (FLO_type)(- MAX_SI_INT - 1);
++          }
++        in.fraction.ll = (-arg_a);
++      }
++      else
++      in.fraction.ll = arg_a;
++
++      while (in.fraction.ll < ((fractype)1 << (FRACBITS + NGARDS)))
++      {
++        in.fraction.ll <<= 1;
++        in.normal_exp -= 1;
++      }
++    }
++  return pack_d (&in);
++}
++#endif /* L_si_to_sf || L_si_to_df */
++
++#if defined(L_usi_to_sf) || defined(L_usi_to_df) || defined(L_usi_to_tf)
++FLO_type
++usi_to_float (USItype arg_a)
++{
++  fp_number_type in;
++
++  in.sign = 0;
++  if (!arg_a)
++    {
++      in.class = CLASS_ZERO;
++    }
++  else
++    {
++      in.class = CLASS_NUMBER;
++      in.normal_exp = FRACBITS + NGARDS;
++      in.fraction.ll = arg_a;
++
++      while (in.fraction.ll > ((fractype)1 << (FRACBITS + NGARDS)))
++        {
++          in.fraction.ll >>= 1;
++          in.normal_exp += 1;
++        }
++      while (in.fraction.ll < ((fractype)1 << (FRACBITS + NGARDS)))
++      {
++        in.fraction.ll <<= 1;
++        in.normal_exp -= 1;
++      }
++    }
++  return pack_d (&in);
++}
++#endif
++
++#if defined(L_sf_to_si) || defined(L_df_to_si) || defined(L_tf_to_si)
++SItype
++float_to_si (FLO_type arg_a)
++{
++  fp_number_type a;
++  SItype tmp;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &a);
++
++  if (iszero (&a))
++    return 0;
++  if (isnan (&a))
++    return 0;
++  /* get reasonable MAX_SI_INT...  */
++  if (isinf (&a))
++    return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
++  /* it is a number, but a small one */
++  if (a.normal_exp < 0)
++    return 0;
++  if (a.normal_exp > BITS_PER_SI - 2)
++    return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
++  tmp = a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
++  return a.sign ? (-tmp) : (tmp);
++}
++#endif /* L_sf_to_si || L_df_to_si */
++
++#if defined(L_sf_to_usi) || defined(L_df_to_usi) || defined(L_tf_to_usi)
++#if defined US_SOFTWARE_GOFAST || defined(L_tf_to_usi)
++/* While libgcc2.c defines its own __fixunssfsi and __fixunsdfsi routines,
++   we also define them for GOFAST because the ones in libgcc2.c have the
++   wrong names and I'd rather define these here and keep GOFAST CYG-LOC's
++   out of libgcc2.c.  We can't define these here if not GOFAST because then
++   there'd be duplicate copies.  */
++
++USItype
++float_to_usi (FLO_type arg_a)
++{
++  fp_number_type a;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &a);
++
++  if (iszero (&a))
++    return 0;
++  if (isnan (&a))
++    return 0;
++  /* it is a negative number */
++  if (a.sign)
++    return 0;
++  /* get reasonable MAX_USI_INT...  */
++  if (isinf (&a))
++    return MAX_USI_INT;
++  /* it is a number, but a small one */
++  if (a.normal_exp < 0)
++    return 0;
++  if (a.normal_exp > BITS_PER_SI - 1)
++    return MAX_USI_INT;
++  else if (a.normal_exp > (FRACBITS + NGARDS))
++    return a.fraction.ll << (a.normal_exp - (FRACBITS + NGARDS));
++  else
++    return a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
++}
++#endif /* US_SOFTWARE_GOFAST */
++#endif /* L_sf_to_usi || L_df_to_usi */
++
++#if defined(L_negate_sf) || defined(L_negate_df) || defined(L_negate_tf)
++FLO_type
++negate (FLO_type arg_a)
++{
++  fp_number_type a;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &a);
++
++  flip_sign (&a);
++  return pack_d (&a);
++}
++#endif /* L_negate_sf || L_negate_df */
++
++#ifdef FLOAT
++
++#if defined(L_make_sf)
++SFtype
++__make_fp(fp_class_type class,
++           unsigned int sign,
++           int exp, 
++           USItype frac)
++{
++  fp_number_type in;
++
++  in.class = class;
++  in.sign = sign;
++  in.normal_exp = exp;
++  in.fraction.ll = frac;
++  return pack_d (&in);
++}
++#endif /* L_make_sf */
++
++#ifndef FLOAT_ONLY
++
++/* This enables one to build an fp library that supports float but not double.
++   Otherwise, we would get an undefined reference to __make_dp.
++   This is needed for some 8-bit ports that can't handle well values that
++   are 8-bytes in size, so we just don't support double for them at all.  */
++
++#if defined(L_sf_to_df)
++DFtype
++sf_to_df (SFtype arg_a)
++{
++  fp_number_type in;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  return __make_dp (in.class, in.sign, in.normal_exp,
++                  ((UDItype) in.fraction.ll) << F_D_BITOFF);
++}
++#endif /* L_sf_to_df */
++
++#if defined(L_sf_to_tf) && defined(TMODES)
++TFtype
++sf_to_tf (SFtype arg_a)
++{
++  fp_number_type in;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  return __make_tp (in.class, in.sign, in.normal_exp,
++                  ((UTItype) in.fraction.ll) << F_T_BITOFF);
++}
++#endif /* L_sf_to_df */
++
++#endif /* ! FLOAT_ONLY */
++#endif /* FLOAT */
++
++#ifndef FLOAT
++
++extern SFtype __make_fp (fp_class_type, unsigned int, int, USItype);
++
++#if defined(L_make_df)
++DFtype
++__make_dp (fp_class_type class, unsigned int sign, int exp, UDItype frac)
++{
++  fp_number_type in;
++
++  in.class = class;
++  in.sign = sign;
++  in.normal_exp = exp;
++  in.fraction.ll = frac;
++  return pack_d (&in);
++}
++#endif /* L_make_df */
++
++#if defined(L_df_to_sf)
++SFtype
++df_to_sf (DFtype arg_a)
++{
++  fp_number_type in;
++  USItype sffrac;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  sffrac = in.fraction.ll >> F_D_BITOFF;
++
++  /* We set the lowest guard bit in SFFRAC if we discarded any non
++     zero bits.  */
++  if ((in.fraction.ll & (((USItype) 1 << F_D_BITOFF) - 1)) != 0)
++    sffrac |= 1;
++
++  return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
++}
++#endif /* L_df_to_sf */
++
++#if defined(L_df_to_tf) && defined(TMODES) \
++    && !defined(FLOAT) && !defined(TFLOAT)
++TFtype
++df_to_tf (DFtype arg_a)
++{
++  fp_number_type in;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  return __make_tp (in.class, in.sign, in.normal_exp,
++                  ((UTItype) in.fraction.ll) << D_T_BITOFF);
++}
++#endif /* L_sf_to_df */
++
++#ifdef TFLOAT
++#if defined(L_make_tf)
++TFtype
++__make_tp(fp_class_type class,
++           unsigned int sign,
++           int exp, 
++           UTItype frac)
++{
++  fp_number_type in;
++
++  in.class = class;
++  in.sign = sign;
++  in.normal_exp = exp;
++  in.fraction.ll = frac;
++  return pack_d (&in);
++}
++#endif /* L_make_tf */
++
++#if defined(L_tf_to_df)
++DFtype
++tf_to_df (TFtype arg_a)
++{
++  fp_number_type in;
++  UDItype sffrac;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  sffrac = in.fraction.ll >> D_T_BITOFF;
++
++  /* We set the lowest guard bit in SFFRAC if we discarded any non
++     zero bits.  */
++  if ((in.fraction.ll & (((UTItype) 1 << D_T_BITOFF) - 1)) != 0)
++    sffrac |= 1;
++
++  return __make_dp (in.class, in.sign, in.normal_exp, sffrac);
++}
++#endif /* L_tf_to_df */
++
++#if defined(L_tf_to_sf)
++SFtype
++tf_to_sf (TFtype arg_a)
++{
++  fp_number_type in;
++  USItype sffrac;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  sffrac = in.fraction.ll >> F_T_BITOFF;
++
++  /* We set the lowest guard bit in SFFRAC if we discarded any non
++     zero bits.  */
++  if ((in.fraction.ll & (((UTItype) 1 << F_T_BITOFF) - 1)) != 0)
++    sffrac |= 1;
++
++  return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
++}
++#endif /* L_tf_to_sf */
++#endif /* TFLOAT */
++
++#endif /* ! FLOAT */
++#endif /* !EXTENDED_FLOAT_STUBS */
+--- ./gcc/gcc/config/nios2/nios2-fp-bit.c
++++ ./gcc/gcc/config/nios2/nios2-fp-bit.c
+@@ -0,0 +1,1652 @@
++#define FLOAT
++/* This is a software floating point library which can be used
++   for targets without hardware floating point. 
++   Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004
++   Free Software Foundation, Inc.
++
++This file is free software; you can redistribute it and/or modify it
++under the terms of the GNU General Public License as published by the
++Free Software Foundation; either version 2, or (at your option) any
++later version.
++
++In addition to the permissions in the GNU General Public License, the
++Free Software Foundation gives you unlimited permission to link the
++compiled version of this file with other programs, and to distribute
++those programs without any restriction coming from the use of this
++file.  (The General Public License restrictions do apply in other
++respects; for example, they cover modification of the file, and
++distribution when not linked into another program.)
++
++This file is distributed in the hope that it will be useful, but
++WITHOUT ANY WARRANTY; without even the implied warranty of
++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++General Public License for more details.
++
++You should have received a copy of the GNU General Public License
++along with this program; see the file COPYING.  If not, write to
++the Free Software Foundation, 59 Temple Place - Suite 330,
++Boston, MA 02111-1307, USA.  */
++
++/* As a special exception, if you link this library with other files,
++   some of which are compiled with GCC, to produce an executable,
++   this library does not by itself cause the resulting executable
++   to be covered by the GNU General Public License.
++   This exception does not however invalidate any other reasons why
++   the executable file might be covered by the GNU General Public License.  */
++
++/* This implements IEEE 754 format arithmetic, but does not provide a
++   mechanism for setting the rounding mode, or for generating or handling
++   exceptions.
++
++   The original code by Steve Chamberlain, hacked by Mark Eichin and Jim
++   Wilson, all of Cygnus Support.  */
++
++/* The intended way to use this file is to make two copies, add `#define FLOAT'
++   to one copy, then compile both copies and add them to libgcc.a.  */
++
++#include "tconfig.h"
++#include "coretypes.h"
++#include "tm.h"
++#include "config/fp-bit.h"
++
++/* The following macros can be defined to change the behavior of this file:
++   FLOAT: Implement a `float', aka SFmode, fp library.  If this is not
++     defined, then this file implements a `double', aka DFmode, fp library.
++   FLOAT_ONLY: Used with FLOAT, to implement a `float' only library, i.e.
++     don't include float->double conversion which requires the double library.
++     This is useful only for machines which can't support doubles, e.g. some
++     8-bit processors.
++   CMPtype: Specify the type that floating point compares should return.
++     This defaults to SItype, aka int.
++   US_SOFTWARE_GOFAST: This makes all entry points use the same names as the
++     US Software goFast library.
++   _DEBUG_BITFLOAT: This makes debugging the code a little easier, by adding
++     two integers to the FLO_union_type.
++   NO_DENORMALS: Disable handling of denormals.
++   NO_NANS: Disable nan and infinity handling
++   SMALL_MACHINE: Useful when operations on QIs and HIs are faster
++     than on an SI */
++
++/* We don't currently support extended floats (long doubles) on machines
++   without hardware to deal with them.
++
++   These stubs are just to keep the linker from complaining about unresolved
++   references which can be pulled in from libio & libstdc++, even if the
++   user isn't using long doubles.  However, they may generate an unresolved
++   external to abort if abort is not used by the function, and the stubs
++   are referenced from within libc, since libgcc goes before and after the
++   system library.  */
++
++#ifdef DECLARE_LIBRARY_RENAMES
++  DECLARE_LIBRARY_RENAMES
++#endif
++
++#ifdef EXTENDED_FLOAT_STUBS
++extern void abort (void);
++void __extendsfxf2 (void) { abort(); }
++void __extenddfxf2 (void) { abort(); }
++void __truncxfdf2 (void) { abort(); }
++void __truncxfsf2 (void) { abort(); }
++void __fixxfsi (void) { abort(); }
++void __floatsixf (void) { abort(); }
++void __addxf3 (void) { abort(); }
++void __subxf3 (void) { abort(); }
++void __mulxf3 (void) { abort(); }
++void __divxf3 (void) { abort(); }
++void __negxf2 (void) { abort(); }
++void __eqxf2 (void) { abort(); }
++void __nexf2 (void) { abort(); }
++void __gtxf2 (void) { abort(); }
++void __gexf2 (void) { abort(); }
++void __lexf2 (void) { abort(); }
++void __ltxf2 (void) { abort(); }
++
++void __extendsftf2 (void) { abort(); }
++void __extenddftf2 (void) { abort(); }
++void __trunctfdf2 (void) { abort(); }
++void __trunctfsf2 (void) { abort(); }
++void __fixtfsi (void) { abort(); }
++void __floatsitf (void) { abort(); }
++void __addtf3 (void) { abort(); }
++void __subtf3 (void) { abort(); }
++void __multf3 (void) { abort(); }
++void __divtf3 (void) { abort(); }
++void __negtf2 (void) { abort(); }
++void __eqtf2 (void) { abort(); }
++void __netf2 (void) { abort(); }
++void __gttf2 (void) { abort(); }
++void __getf2 (void) { abort(); }
++void __letf2 (void) { abort(); }
++void __lttf2 (void) { abort(); }
++#else /* !EXTENDED_FLOAT_STUBS, rest of file */
++
++/* IEEE "special" number predicates */
++
++#ifdef NO_NANS
++
++#define nan() 0
++#define isnan(x) 0
++#define isinf(x) 0
++#else
++
++#if   defined L_thenan_sf
++const fp_number_type __thenan_sf = { CLASS_SNAN, 0, 0, {(fractype) 0} };
++#elif defined L_thenan_df
++const fp_number_type __thenan_df = { CLASS_SNAN, 0, 0, {(fractype) 0} };
++#elif defined L_thenan_tf
++const fp_number_type __thenan_tf = { CLASS_SNAN, 0, 0, {(fractype) 0} };
++#elif defined TFLOAT
++extern const fp_number_type __thenan_tf;
++#elif defined FLOAT
++extern const fp_number_type __thenan_sf;
++#else
++extern const fp_number_type __thenan_df;
++#endif
++
++INLINE
++static fp_number_type *
++nan (void)
++{
++  /* Discard the const qualifier...  */
++#ifdef TFLOAT
++  return (fp_number_type *) (& __thenan_tf);
++#elif defined FLOAT  
++  return (fp_number_type *) (& __thenan_sf);
++#else
++  return (fp_number_type *) (& __thenan_df);
++#endif
++}
++
++INLINE
++static int
++isnan ( fp_number_type *  x)
++{
++  return x->class == CLASS_SNAN || x->class == CLASS_QNAN;
++}
++
++INLINE
++static int
++isinf ( fp_number_type *  x)
++{
++  return x->class == CLASS_INFINITY;
++}
++
++#endif /* NO_NANS */
++
++INLINE
++static int
++iszero ( fp_number_type *  x)
++{
++  return x->class == CLASS_ZERO;
++}
++
++INLINE 
++static void
++flip_sign ( fp_number_type *  x)
++{
++  x->sign = !x->sign;
++}
++
++extern FLO_type pack_d ( fp_number_type * );
++
++#if defined(L_pack_df) || defined(L_pack_sf) || defined(L_pack_tf)
++FLO_type
++pack_d ( fp_number_type *  src)
++{
++  FLO_union_type dst;
++  fractype fraction = src->fraction.ll;       /* wasn't unsigned before? */
++  int sign = src->sign;
++  int exp = 0;
++
++  if (LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && (isnan (src) || isinf (src)))
++    {
++      /* We can't represent these values accurately.  By using the
++       largest possible magnitude, we guarantee that the conversion
++       of infinity is at least as big as any finite number.  */
++      exp = EXPMAX;
++      fraction = ((fractype) 1 << FRACBITS) - 1;
++    }
++  else if (isnan (src))
++    {
++      exp = EXPMAX;
++      if (src->class == CLASS_QNAN || 1)
++      {
++#ifdef QUIET_NAN_NEGATED
++        fraction |= QUIET_NAN - 1;
++#else
++        fraction |= QUIET_NAN;
++#endif
++      }
++    }
++  else if (isinf (src))
++    {
++      exp = EXPMAX;
++      fraction = 0;
++    }
++  else if (iszero (src))
++    {
++      exp = 0;
++      fraction = 0;
++    }
++  else if (fraction == 0)
++    {
++      exp = 0;
++    }
++  else
++    {
++      if (src->normal_exp < NORMAL_EXPMIN)
++      {
++#ifdef NO_DENORMALS
++        /* Go straight to a zero representation if denormals are not
++           supported.  The denormal handling would be harmless but
++           isn't unnecessary.  */
++        exp = 0;
++        fraction = 0;
++#else /* NO_DENORMALS */
++        /* This number's exponent is too low to fit into the bits
++           available in the number, so we'll store 0 in the exponent and
++           shift the fraction to the right to make up for it.  */
++
++        int shift = NORMAL_EXPMIN - src->normal_exp;
++
++        exp = 0;
++
++        if (shift > FRAC_NBITS - NGARDS)
++          {
++            /* No point shifting, since it's more that 64 out.  */
++            fraction = 0;
++          }
++        else
++          {
++            int lowbit = (fraction & (((fractype)1 << shift) - 1)) ? 1 : 0;
++            fraction = (fraction >> shift) | lowbit;
++          }
++        if ((fraction & GARDMASK) == GARDMSB)
++          {
++            if ((fraction & (1 << NGARDS)))
++              fraction += GARDROUND + 1;
++          }
++        else
++          {
++            /* Add to the guards to round up.  */
++            fraction += GARDROUND;
++          }
++        /* Perhaps the rounding means we now need to change the
++             exponent, because the fraction is no longer denormal.  */
++        if (fraction >= IMPLICIT_1)
++          {
++            exp += 1;
++          }
++        fraction >>= NGARDS;
++#endif /* NO_DENORMALS */
++      }
++      else if (!LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS)
++             && src->normal_exp > EXPBIAS)
++      {
++        exp = EXPMAX;
++        fraction = 0;
++      }
++      else
++      {
++        exp = src->normal_exp + EXPBIAS;
++        if (!ROUND_TOWARDS_ZERO)
++          {
++            /* IF the gard bits are the all zero, but the first, then we're
++               half way between two numbers, choose the one which makes the
++               lsb of the answer 0.  */
++            if ((fraction & GARDMASK) == GARDMSB)
++              {
++                if (fraction & (1 << NGARDS))
++                  fraction += GARDROUND + 1;
++              }
++            else
++              {
++                /* Add a one to the guards to round up */
++                fraction += GARDROUND;
++              }
++            if (fraction >= IMPLICIT_2)
++              {
++                fraction >>= 1;
++                exp += 1;
++              }
++          }
++        fraction >>= NGARDS;
++
++        if (LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && exp > EXPMAX)
++          {
++            /* Saturate on overflow.  */
++            exp = EXPMAX;
++            fraction = ((fractype) 1 << FRACBITS) - 1;
++          }
++      }
++    }
++
++  /* We previously used bitfields to store the number, but this doesn't
++     handle little/big endian systems conveniently, so use shifts and
++     masks */
++#ifdef FLOAT_BIT_ORDER_MISMATCH
++  dst.bits.fraction = fraction;
++  dst.bits.exp = exp;
++  dst.bits.sign = sign;
++#else
++# if defined TFLOAT && defined HALFFRACBITS
++ {
++   halffractype high, low, unity;
++   int lowsign, lowexp;
++
++   unity = (halffractype) 1 << HALFFRACBITS;
++
++   /* Set HIGH to the high double's significand, masking out the implicit 1.
++      Set LOW to the low double's full significand.  */
++   high = (fraction >> (FRACBITS - HALFFRACBITS)) & (unity - 1);
++   low = fraction & (unity * 2 - 1);
++
++   /* Get the initial sign and exponent of the low double.  */
++   lowexp = exp - HALFFRACBITS - 1;
++   lowsign = sign;
++
++   /* HIGH should be rounded like a normal double, making |LOW| <=
++      0.5 ULP of HIGH.  Assume round-to-nearest.  */
++   if (exp < EXPMAX)
++     if (low > unity || (low == unity && (high & 1) == 1))
++       {
++       /* Round HIGH up and adjust LOW to match.  */
++       high++;
++       if (high == unity)
++         {
++           /* May make it infinite, but that's OK.  */
++           high = 0;
++           exp++;
++         }
++       low = unity * 2 - low;
++       lowsign ^= 1;
++       }
++
++   high |= (halffractype) exp << HALFFRACBITS;
++   high |= (halffractype) sign << (HALFFRACBITS + EXPBITS);
++
++   if (exp == EXPMAX || exp == 0 || low == 0)
++     low = 0;
++   else
++     {
++       while (lowexp > 0 && low < unity)
++       {
++         low <<= 1;
++         lowexp--;
++       }
++
++       if (lowexp <= 0)
++       {
++         halffractype roundmsb, round;
++         int shift;
++
++         shift = 1 - lowexp;
++         roundmsb = (1 << (shift - 1));
++         round = low & ((roundmsb << 1) - 1);
++
++         low >>= shift;
++         lowexp = 0;
++
++         if (round > roundmsb || (round == roundmsb && (low & 1) == 1))
++           {
++             low++;
++             if (low == unity)
++               /* LOW rounds up to the smallest normal number.  */
++               lowexp++;
++           }
++       }
++
++       low &= unity - 1;
++       low |= (halffractype) lowexp << HALFFRACBITS;
++       low |= (halffractype) lowsign << (HALFFRACBITS + EXPBITS);
++     }
++   dst.value_raw = ((fractype) high << HALFSHIFT) | low;
++ }
++# else
++  dst.value_raw = fraction & ((((fractype)1) << FRACBITS) - (fractype)1);
++  dst.value_raw |= ((fractype) (exp & ((1 << EXPBITS) - 1))) << FRACBITS;
++  dst.value_raw |= ((fractype) (sign & 1)) << (FRACBITS | EXPBITS);
++# endif
++#endif
++
++#if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
++#ifdef TFLOAT
++  {
++    qrtrfractype tmp1 = dst.words[0];
++    qrtrfractype tmp2 = dst.words[1];
++    dst.words[0] = dst.words[3];
++    dst.words[1] = dst.words[2];
++    dst.words[2] = tmp2;
++    dst.words[3] = tmp1;
++  }
++#else
++  {
++    halffractype tmp = dst.words[0];
++    dst.words[0] = dst.words[1];
++    dst.words[1] = tmp;
++  }
++#endif
++#endif
++
++  return dst.value;
++}
++#endif
++
++#if defined(L_unpack_df) || defined(L_unpack_sf) || defined(L_unpack_tf)
++void
++unpack_d (FLO_union_type * src, fp_number_type * dst)
++{
++  /* We previously used bitfields to store the number, but this doesn't
++     handle little/big endian systems conveniently, so use shifts and
++     masks */
++  fractype fraction;
++  int exp;
++  int sign;
++
++#if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
++  FLO_union_type swapped;
++
++#ifdef TFLOAT
++  swapped.words[0] = src->words[3];
++  swapped.words[1] = src->words[2];
++  swapped.words[2] = src->words[1];
++  swapped.words[3] = src->words[0];
++#else
++  swapped.words[0] = src->words[1];
++  swapped.words[1] = src->words[0];
++#endif
++  src = &swapped;
++#endif
++  
++#ifdef FLOAT_BIT_ORDER_MISMATCH
++  fraction = src->bits.fraction;
++  exp = src->bits.exp;
++  sign = src->bits.sign;
++#else
++# if defined TFLOAT && defined HALFFRACBITS
++ {
++   halffractype high, low;
++   
++   high = src->value_raw >> HALFSHIFT;
++   low = src->value_raw & (((fractype)1 << HALFSHIFT) - 1);
++
++   fraction = high & ((((fractype)1) << HALFFRACBITS) - 1);
++   fraction <<= FRACBITS - HALFFRACBITS;
++   exp = ((int)(high >> HALFFRACBITS)) & ((1 << EXPBITS) - 1);
++   sign = ((int)(high >> (((HALFFRACBITS + EXPBITS))))) & 1;
++
++   if (exp != EXPMAX && exp != 0 && low != 0)
++     {
++       int lowexp = ((int)(low >> HALFFRACBITS)) & ((1 << EXPBITS) - 1);
++       int lowsign = ((int)(low >> (((HALFFRACBITS + EXPBITS))))) & 1;
++       int shift;
++       fractype xlow;
++
++       xlow = low & ((((fractype)1) << HALFFRACBITS) - 1);
++       if (lowexp)
++       xlow |= (((halffractype)1) << HALFFRACBITS);
++       else
++       lowexp = 1;
++       shift = (FRACBITS - HALFFRACBITS) - (exp - lowexp);
++       if (shift > 0)
++       xlow <<= shift;
++       else if (shift < 0)
++       xlow >>= -shift;
++       if (sign == lowsign)
++       fraction += xlow;
++       else if (fraction >= xlow)
++       fraction -= xlow;
++       else
++       {
++         /* The high part is a power of two but the full number is lower.
++            This code will leave the implicit 1 in FRACTION, but we'd
++            have added that below anyway.  */
++         fraction = (((fractype) 1 << FRACBITS) - xlow) << 1;
++         exp--;
++       }
++     }
++ }
++# else
++  fraction = src->value_raw & ((((fractype)1) << FRACBITS) - 1);
++  exp = ((int)(src->value_raw >> FRACBITS)) & ((1 << EXPBITS) - 1);
++  sign = ((int)(src->value_raw >> (FRACBITS + EXPBITS))) & 1;
++# endif
++#endif
++
++  dst->sign = sign;
++  if (exp == 0)
++    {
++      /* Hmm.  Looks like 0 */
++      if (fraction == 0
++#ifdef NO_DENORMALS
++        || 1
++#endif
++        )
++      {
++        /* tastes like zero */
++        dst->class = CLASS_ZERO;
++      }
++      else
++      {
++        /* Zero exponent with nonzero fraction - it's denormalized,
++           so there isn't a leading implicit one - we'll shift it so
++           it gets one.  */
++        dst->normal_exp = exp - EXPBIAS + 1;
++        fraction <<= NGARDS;
++
++        dst->class = CLASS_NUMBER;
++#if 1
++        while (fraction < IMPLICIT_1)
++          {
++            fraction <<= 1;
++            dst->normal_exp--;
++          }
++#endif
++        dst->fraction.ll = fraction;
++      }
++    }
++  else if (!LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && exp == EXPMAX)
++    {
++      /* Huge exponent*/
++      if (fraction == 0)
++      {
++        /* Attached to a zero fraction - means infinity */
++        dst->class = CLASS_INFINITY;
++      }
++      else
++      {
++        /* Nonzero fraction, means nan */
++#ifdef QUIET_NAN_NEGATED
++        if ((fraction & QUIET_NAN) == 0)
++#else
++        if (fraction & QUIET_NAN)
++#endif
++          {
++            dst->class = CLASS_QNAN;
++          }
++        else
++          {
++            dst->class = CLASS_SNAN;
++          }
++        /* Keep the fraction part as the nan number */
++        dst->fraction.ll = fraction;
++      }
++    }
++  else
++    {
++      /* Nothing strange about this number */
++      dst->normal_exp = exp - EXPBIAS;
++      dst->class = CLASS_NUMBER;
++      dst->fraction.ll = (fraction << NGARDS) | IMPLICIT_1;
++    }
++}
++#endif /* L_unpack_df || L_unpack_sf */
++
++#if defined(L_addsub_sf) || defined(L_addsub_df) || defined(L_addsub_tf)
++static fp_number_type *
++_fpadd_parts (fp_number_type * a,
++            fp_number_type * b,
++            fp_number_type * tmp)
++{
++  intfrac tfraction;
++
++  /* Put commonly used fields in local variables.  */
++  int a_normal_exp;
++  int b_normal_exp;
++  fractype a_fraction;
++  fractype b_fraction;
++
++  if (isnan (a))
++    {
++      return a;
++    }
++  if (isnan (b))
++    {
++      return b;
++    }
++  if (isinf (a))
++    {
++      /* Adding infinities with opposite signs yields a NaN.  */
++      if (isinf (b) && a->sign != b->sign)
++      return nan ();
++      return a;
++    }
++  if (isinf (b))
++    {
++      return b;
++    }
++  if (iszero (b))
++    {
++      if (iszero (a))
++      {
++        *tmp = *a;
++        tmp->sign = a->sign & b->sign;
++        return tmp;
++      }
++      return a;
++    }
++  if (iszero (a))
++    {
++      return b;
++    }
++
++  /* Got two numbers. shift the smaller and increment the exponent till
++     they're the same */
++  {
++    int diff;
++
++    a_normal_exp = a->normal_exp;
++    b_normal_exp = b->normal_exp;
++    a_fraction = a->fraction.ll;
++    b_fraction = b->fraction.ll;
++
++    diff = a_normal_exp - b_normal_exp;
++
++    if (diff < 0)
++      diff = -diff;
++    if (diff < FRAC_NBITS)
++      {
++      /* ??? This does shifts one bit at a time.  Optimize.  */
++      while (a_normal_exp > b_normal_exp)
++        {
++          b_normal_exp++;
++          LSHIFT (b_fraction);
++        }
++      while (b_normal_exp > a_normal_exp)
++        {
++          a_normal_exp++;
++          LSHIFT (a_fraction);
++        }
++      }
++    else
++      {
++      /* Somethings's up.. choose the biggest */
++      if (a_normal_exp > b_normal_exp)
++        {
++          b_normal_exp = a_normal_exp;
++          b_fraction = 0;
++        }
++      else
++        {
++          a_normal_exp = b_normal_exp;
++          a_fraction = 0;
++        }
++      }
++  }
++
++  if (a->sign != b->sign)
++    {
++      if (a->sign)
++      {
++        tfraction = -a_fraction + b_fraction;
++      }
++      else
++      {
++        tfraction = a_fraction - b_fraction;
++      }
++      if (tfraction >= 0)
++      {
++        tmp->sign = 0;
++        tmp->normal_exp = a_normal_exp;
++        tmp->fraction.ll = tfraction;
++      }
++      else
++      {
++        tmp->sign = 1;
++        tmp->normal_exp = a_normal_exp;
++        tmp->fraction.ll = -tfraction;
++      }
++      /* and renormalize it */
++
++      while (tmp->fraction.ll < IMPLICIT_1 && tmp->fraction.ll)
++      {
++        tmp->fraction.ll <<= 1;
++        tmp->normal_exp--;
++      }
++    }
++  else
++    {
++      tmp->sign = a->sign;
++      tmp->normal_exp = a_normal_exp;
++      tmp->fraction.ll = a_fraction + b_fraction;
++    }
++  tmp->class = CLASS_NUMBER;
++  /* Now the fraction is added, we have to shift down to renormalize the
++     number */
++
++  if (tmp->fraction.ll >= IMPLICIT_2)
++    {
++      LSHIFT (tmp->fraction.ll);
++      tmp->normal_exp++;
++    }
++  return tmp;
++
++}
++
++FLO_type
++add (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  fp_number_type tmp;
++  fp_number_type *res;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  res = _fpadd_parts (&a, &b, &tmp);
++
++  return pack_d (res);
++}
++
++FLO_type
++sub (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  fp_number_type tmp;
++  fp_number_type *res;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  b.sign ^= 1;
++
++  res = _fpadd_parts (&a, &b, &tmp);
++
++  return pack_d (res);
++}
++#endif /* L_addsub_sf || L_addsub_df */
++
++#if defined(L_mul_sf) || defined(L_mul_df) || defined(L_mul_tf)
++static inline __attribute__ ((__always_inline__)) fp_number_type *
++_fpmul_parts ( fp_number_type *  a,
++             fp_number_type *  b,
++             fp_number_type * tmp)
++{
++  fractype low = 0;
++  fractype high = 0;
++
++  if (isnan (a))
++    {
++      a->sign = a->sign != b->sign;
++      return a;
++    }
++  if (isnan (b))
++    {
++      b->sign = a->sign != b->sign;
++      return b;
++    }
++  if (isinf (a))
++    {
++      if (iszero (b))
++      return nan ();
++      a->sign = a->sign != b->sign;
++      return a;
++    }
++  if (isinf (b))
++    {
++      if (iszero (a))
++      {
++        return nan ();
++      }
++      b->sign = a->sign != b->sign;
++      return b;
++    }
++  if (iszero (a))
++    {
++      a->sign = a->sign != b->sign;
++      return a;
++    }
++  if (iszero (b))
++    {
++      b->sign = a->sign != b->sign;
++      return b;
++    }
++
++  /* Calculate the mantissa by multiplying both numbers to get a
++     twice-as-wide number.  */
++  {
++#if defined(NO_DI_MODE) || defined(TFLOAT)
++    {
++      fractype x = a->fraction.ll;
++      fractype ylow = b->fraction.ll;
++      fractype yhigh = 0;
++      int bit;
++
++      /* ??? This does multiplies one bit at a time.  Optimize.  */
++      for (bit = 0; bit < FRAC_NBITS; bit++)
++      {
++        int carry;
++
++        if (x & 1)
++          {
++            carry = (low += ylow) < ylow;
++            high += yhigh + carry;
++          }
++        yhigh <<= 1;
++        if (ylow & FRACHIGH)
++          {
++            yhigh |= 1;
++          }
++        ylow <<= 1;
++        x >>= 1;
++      }
++    }
++#elif defined(FLOAT) 
++    /* Multiplying two USIs to get a UDI, we're safe.  */
++    {
++      UDItype answer = (UDItype)a->fraction.ll * (UDItype)b->fraction.ll;
++      
++      high = answer >> BITS_PER_SI;
++      low = answer;
++    }
++#else
++    /* fractype is DImode, but we need the result to be twice as wide.
++       Assuming a widening multiply from DImode to TImode is not
++       available, build one by hand.  */
++    {
++      USItype nl = a->fraction.ll;
++      USItype nh = a->fraction.ll >> BITS_PER_SI;
++      USItype ml = b->fraction.ll;
++      USItype mh = b->fraction.ll >> BITS_PER_SI;
++      UDItype pp_ll = (UDItype) ml * nl;
++      UDItype pp_hl = (UDItype) mh * nl;
++      UDItype pp_lh = (UDItype) ml * nh;
++      UDItype pp_hh = (UDItype) mh * nh;
++      UDItype res2 = 0;
++      UDItype res0 = 0;
++      UDItype ps_hh__ = pp_hl + pp_lh;
++      if (ps_hh__ < pp_hl)
++      res2 += (UDItype)1 << BITS_PER_SI;
++      pp_hl = (UDItype)(USItype)ps_hh__ << BITS_PER_SI;
++      res0 = pp_ll + pp_hl;
++      if (res0 < pp_ll)
++      res2++;
++      res2 += (ps_hh__ >> BITS_PER_SI) + pp_hh;
++      high = res2;
++      low = res0;
++    }
++#endif
++  }
++
++  tmp->normal_exp = a->normal_exp + b->normal_exp
++    + FRAC_NBITS - (FRACBITS + NGARDS);
++  tmp->sign = a->sign != b->sign;
++  while (high >= IMPLICIT_2)
++    {
++      tmp->normal_exp++;
++      if (high & 1)
++      {
++        low >>= 1;
++        low |= FRACHIGH;
++      }
++      high >>= 1;
++    }
++  while (high < IMPLICIT_1)
++    {
++      tmp->normal_exp--;
++
++      high <<= 1;
++      if (low & FRACHIGH)
++      high |= 1;
++      low <<= 1;
++    }
++  /* rounding is tricky. if we only round if it won't make us round later.  */
++#if 0
++  if (low & FRACHIGH2)
++    {
++      if (((high & GARDMASK) != GARDMSB)
++        && (((high + 1) & GARDMASK) == GARDMSB))
++      {
++        /* don't round, it gets done again later.  */
++      }
++      else
++      {
++        high++;
++      }
++    }
++#endif
++  if (!ROUND_TOWARDS_ZERO && (high & GARDMASK) == GARDMSB)
++    {
++      if (high & (1 << NGARDS))
++      {
++        /* half way, so round to even */
++        high += GARDROUND + 1;
++      }
++      else if (low)
++      {
++        /* but we really weren't half way */
++        high += GARDROUND + 1;
++      }
++    }
++  tmp->fraction.ll = high;
++  tmp->class = CLASS_NUMBER;
++  return tmp;
++}
++
++FLO_type
++multiply (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  fp_number_type tmp;
++  fp_number_type *res;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  res = _fpmul_parts (&a, &b, &tmp);
++
++  return pack_d (res);
++}
++#endif /* L_mul_sf || L_mul_df */
++
++#if defined(L_div_sf) || defined(L_div_df) || defined(L_div_tf)
++static inline __attribute__ ((__always_inline__)) fp_number_type *
++_fpdiv_parts (fp_number_type * a,
++            fp_number_type * b)
++{
++  fractype bit;
++  fractype numerator;
++  fractype denominator;
++  fractype quotient;
++
++  if (isnan (a))
++    {
++      return a;
++    }
++  if (isnan (b))
++    {
++      return b;
++    }
++
++  a->sign = a->sign ^ b->sign;
++
++  if (isinf (a) || iszero (a))
++    {
++      if (a->class == b->class)
++      return nan ();
++      return a;
++    }
++
++  if (isinf (b))
++    {
++      a->fraction.ll = 0;
++      a->normal_exp = 0;
++      return a;
++    }
++  if (iszero (b))
++    {
++      a->class = CLASS_INFINITY;
++      return a;
++    }
++
++  /* Calculate the mantissa by multiplying both 64bit numbers to get a
++     128 bit number */
++  {
++    /* quotient =
++       ( numerator / denominator) * 2^(numerator exponent -  denominator exponent)
++     */
++
++    a->normal_exp = a->normal_exp - b->normal_exp;
++    numerator = a->fraction.ll;
++    denominator = b->fraction.ll;
++
++    if (numerator < denominator)
++      {
++      /* Fraction will be less than 1.0 */
++      numerator *= 2;
++      a->normal_exp--;
++      }
++    bit = IMPLICIT_1;
++    quotient = 0;
++    /* ??? Does divide one bit at a time.  Optimize.  */
++    while (bit)
++      {
++      if (numerator >= denominator)
++        {
++          quotient |= bit;
++          numerator -= denominator;
++        }
++      bit >>= 1;
++      numerator *= 2;
++      }
++
++    if (!ROUND_TOWARDS_ZERO && (quotient & GARDMASK) == GARDMSB)
++      {
++      if (quotient & (1 << NGARDS))
++        {
++          /* half way, so round to even */
++          quotient += GARDROUND + 1;
++        }
++      else if (numerator)
++        {
++          /* but we really weren't half way, more bits exist */
++          quotient += GARDROUND + 1;
++        }
++      }
++
++    a->fraction.ll = quotient;
++    return (a);
++  }
++}
++
++FLO_type
++divide (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  fp_number_type *res;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  res = _fpdiv_parts (&a, &b);
++
++  return pack_d (res);
++}
++#endif /* L_div_sf || L_div_df */
++
++#if defined(L_fpcmp_parts_sf) || defined(L_fpcmp_parts_df) \
++    || defined(L_fpcmp_parts_tf)
++/* according to the demo, fpcmp returns a comparison with 0... thus
++   a<b -> -1
++   a==b -> 0
++   a>b -> +1
++ */
++
++int
++__fpcmp_parts (fp_number_type * a, fp_number_type * b)
++{
++#if 0
++  /* either nan -> unordered. Must be checked outside of this routine.  */
++  if (isnan (a) && isnan (b))
++    {
++      return 1;                       /* still unordered! */
++    }
++#endif
++
++  if (isnan (a) || isnan (b))
++    {
++      return 1;                       /* how to indicate unordered compare? */
++    }
++  if (isinf (a) && isinf (b))
++    {
++      /* +inf > -inf, but +inf != +inf */
++      /* b    \a| +inf(0)| -inf(1)
++       ______\+--------+--------
++       +inf(0)| a==b(0)| a<b(-1)
++       -------+--------+--------
++       -inf(1)| a>b(1) | a==b(0)
++       -------+--------+--------
++       So since unordered must be nonzero, just line up the columns...
++       */
++      return b->sign - a->sign;
++    }
++  /* but not both...  */
++  if (isinf (a))
++    {
++      return a->sign ? -1 : 1;
++    }
++  if (isinf (b))
++    {
++      return b->sign ? 1 : -1;
++    }
++  if (iszero (a) && iszero (b))
++    {
++      return 0;
++    }
++  if (iszero (a))
++    {
++      return b->sign ? 1 : -1;
++    }
++  if (iszero (b))
++    {
++      return a->sign ? -1 : 1;
++    }
++  /* now both are "normal".  */
++  if (a->sign != b->sign)
++    {
++      /* opposite signs */
++      return a->sign ? -1 : 1;
++    }
++  /* same sign; exponents? */
++  if (a->normal_exp > b->normal_exp)
++    {
++      return a->sign ? -1 : 1;
++    }
++  if (a->normal_exp < b->normal_exp)
++    {
++      return a->sign ? 1 : -1;
++    }
++  /* same exponents; check size.  */
++  if (a->fraction.ll > b->fraction.ll)
++    {
++      return a->sign ? -1 : 1;
++    }
++  if (a->fraction.ll < b->fraction.ll)
++    {
++      return a->sign ? 1 : -1;
++    }
++  /* after all that, they're equal.  */
++  return 0;
++}
++#endif
++
++#if defined(L_compare_sf) || defined(L_compare_df) || defined(L_compoare_tf)
++CMPtype
++compare (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  return __fpcmp_parts (&a, &b);
++}
++#endif /* L_compare_sf || L_compare_df */
++
++#ifndef US_SOFTWARE_GOFAST
++
++/* These should be optimized for their specific tasks someday.  */
++
++#if defined(L_eq_sf) || defined(L_eq_df) || defined(L_eq_tf)
++CMPtype
++_eq_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return 1;                 /* false, truth == 0 */
++
++  return __fpcmp_parts (&a, &b) ;
++}
++#endif /* L_eq_sf || L_eq_df */
++
++#if defined(L_ne_sf) || defined(L_ne_df) || defined(L_ne_tf)
++CMPtype
++_ne_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return 1;                 /* true, truth != 0 */
++
++  return  __fpcmp_parts (&a, &b) ;
++}
++#endif /* L_ne_sf || L_ne_df */
++
++#if defined(L_gt_sf) || defined(L_gt_df) || defined(L_gt_tf)
++CMPtype
++_gt_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return -1;                        /* false, truth > 0 */
++
++  return __fpcmp_parts (&a, &b);
++}
++#endif /* L_gt_sf || L_gt_df */
++
++#if defined(L_ge_sf) || defined(L_ge_df) || defined(L_ge_tf)
++CMPtype
++_ge_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return -1;                        /* false, truth >= 0 */
++  return __fpcmp_parts (&a, &b) ;
++}
++#endif /* L_ge_sf || L_ge_df */
++
++#if defined(L_lt_sf) || defined(L_lt_df) || defined(L_lt_tf)
++CMPtype
++_lt_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return 1;                 /* false, truth < 0 */
++
++  return __fpcmp_parts (&a, &b);
++}
++#endif /* L_lt_sf || L_lt_df */
++
++#if defined(L_le_sf) || defined(L_le_df) || defined(L_le_tf)
++CMPtype
++_le_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  if (isnan (&a) || isnan (&b))
++    return 1;                 /* false, truth <= 0 */
++
++  return __fpcmp_parts (&a, &b) ;
++}
++#endif /* L_le_sf || L_le_df */
++
++#endif /* ! US_SOFTWARE_GOFAST */
++
++#if defined(L_unord_sf) || defined(L_unord_df) || defined(L_unord_tf)
++CMPtype
++_unord_f2 (FLO_type arg_a, FLO_type arg_b)
++{
++  fp_number_type a;
++  fp_number_type b;
++  FLO_union_type au, bu;
++
++  au.value = arg_a;
++  bu.value = arg_b;
++
++  unpack_d (&au, &a);
++  unpack_d (&bu, &b);
++
++  return (isnan (&a) || isnan (&b));
++}
++#endif /* L_unord_sf || L_unord_df */
++
++#if defined(L_si_to_sf) || defined(L_si_to_df) || defined(L_si_to_tf)
++FLO_type
++si_to_float (SItype arg_a)
++{
++  fp_number_type in;
++
++  in.class = CLASS_NUMBER;
++  in.sign = arg_a < 0;
++  if (!arg_a)
++    {
++      in.class = CLASS_ZERO;
++    }
++  else
++    {
++      in.normal_exp = FRACBITS + NGARDS;
++      if (in.sign) 
++      {
++        /* Special case for minint, since there is no +ve integer
++           representation for it */
++        if (arg_a == (- MAX_SI_INT - 1))
++          {
++            return (FLO_type)(- MAX_SI_INT - 1);
++          }
++        in.fraction.ll = (-arg_a);
++      }
++      else
++      in.fraction.ll = arg_a;
++
++      while (in.fraction.ll < ((fractype)1 << (FRACBITS + NGARDS)))
++      {
++        in.fraction.ll <<= 1;
++        in.normal_exp -= 1;
++      }
++    }
++  return pack_d (&in);
++}
++#endif /* L_si_to_sf || L_si_to_df */
++
++#if defined(L_usi_to_sf) || defined(L_usi_to_df) || defined(L_usi_to_tf)
++FLO_type
++usi_to_float (USItype arg_a)
++{
++  fp_number_type in;
++
++  in.sign = 0;
++  if (!arg_a)
++    {
++      in.class = CLASS_ZERO;
++    }
++  else
++    {
++      in.class = CLASS_NUMBER;
++      in.normal_exp = FRACBITS + NGARDS;
++      in.fraction.ll = arg_a;
++
++      while (in.fraction.ll > ((fractype)1 << (FRACBITS + NGARDS)))
++        {
++          in.fraction.ll >>= 1;
++          in.normal_exp += 1;
++        }
++      while (in.fraction.ll < ((fractype)1 << (FRACBITS + NGARDS)))
++      {
++        in.fraction.ll <<= 1;
++        in.normal_exp -= 1;
++      }
++    }
++  return pack_d (&in);
++}
++#endif
++
++#if defined(L_sf_to_si) || defined(L_df_to_si) || defined(L_tf_to_si)
++SItype
++float_to_si (FLO_type arg_a)
++{
++  fp_number_type a;
++  SItype tmp;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &a);
++
++  if (iszero (&a))
++    return 0;
++  if (isnan (&a))
++    return 0;
++  /* get reasonable MAX_SI_INT...  */
++  if (isinf (&a))
++    return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
++  /* it is a number, but a small one */
++  if (a.normal_exp < 0)
++    return 0;
++  if (a.normal_exp > BITS_PER_SI - 2)
++    return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
++  tmp = a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
++  return a.sign ? (-tmp) : (tmp);
++}
++#endif /* L_sf_to_si || L_df_to_si */
++
++#if defined(L_sf_to_usi) || defined(L_df_to_usi) || defined(L_tf_to_usi)
++#if defined US_SOFTWARE_GOFAST || defined(L_tf_to_usi)
++/* While libgcc2.c defines its own __fixunssfsi and __fixunsdfsi routines,
++   we also define them for GOFAST because the ones in libgcc2.c have the
++   wrong names and I'd rather define these here and keep GOFAST CYG-LOC's
++   out of libgcc2.c.  We can't define these here if not GOFAST because then
++   there'd be duplicate copies.  */
++
++USItype
++float_to_usi (FLO_type arg_a)
++{
++  fp_number_type a;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &a);
++
++  if (iszero (&a))
++    return 0;
++  if (isnan (&a))
++    return 0;
++  /* it is a negative number */
++  if (a.sign)
++    return 0;
++  /* get reasonable MAX_USI_INT...  */
++  if (isinf (&a))
++    return MAX_USI_INT;
++  /* it is a number, but a small one */
++  if (a.normal_exp < 0)
++    return 0;
++  if (a.normal_exp > BITS_PER_SI - 1)
++    return MAX_USI_INT;
++  else if (a.normal_exp > (FRACBITS + NGARDS))
++    return a.fraction.ll << (a.normal_exp - (FRACBITS + NGARDS));
++  else
++    return a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
++}
++#endif /* US_SOFTWARE_GOFAST */
++#endif /* L_sf_to_usi || L_df_to_usi */
++
++#if defined(L_negate_sf) || defined(L_negate_df) || defined(L_negate_tf)
++FLO_type
++negate (FLO_type arg_a)
++{
++  fp_number_type a;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &a);
++
++  flip_sign (&a);
++  return pack_d (&a);
++}
++#endif /* L_negate_sf || L_negate_df */
++
++#ifdef FLOAT
++
++#if defined(L_make_sf)
++SFtype
++__make_fp(fp_class_type class,
++           unsigned int sign,
++           int exp, 
++           USItype frac)
++{
++  fp_number_type in;
++
++  in.class = class;
++  in.sign = sign;
++  in.normal_exp = exp;
++  in.fraction.ll = frac;
++  return pack_d (&in);
++}
++#endif /* L_make_sf */
++
++#ifndef FLOAT_ONLY
++
++/* This enables one to build an fp library that supports float but not double.
++   Otherwise, we would get an undefined reference to __make_dp.
++   This is needed for some 8-bit ports that can't handle well values that
++   are 8-bytes in size, so we just don't support double for them at all.  */
++
++#if defined(L_sf_to_df)
++DFtype
++sf_to_df (SFtype arg_a)
++{
++  fp_number_type in;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  return __make_dp (in.class, in.sign, in.normal_exp,
++                  ((UDItype) in.fraction.ll) << F_D_BITOFF);
++}
++#endif /* L_sf_to_df */
++
++#if defined(L_sf_to_tf) && defined(TMODES)
++TFtype
++sf_to_tf (SFtype arg_a)
++{
++  fp_number_type in;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  return __make_tp (in.class, in.sign, in.normal_exp,
++                  ((UTItype) in.fraction.ll) << F_T_BITOFF);
++}
++#endif /* L_sf_to_df */
++
++#endif /* ! FLOAT_ONLY */
++#endif /* FLOAT */
++
++#ifndef FLOAT
++
++extern SFtype __make_fp (fp_class_type, unsigned int, int, USItype);
++
++#if defined(L_make_df)
++DFtype
++__make_dp (fp_class_type class, unsigned int sign, int exp, UDItype frac)
++{
++  fp_number_type in;
++
++  in.class = class;
++  in.sign = sign;
++  in.normal_exp = exp;
++  in.fraction.ll = frac;
++  return pack_d (&in);
++}
++#endif /* L_make_df */
++
++#if defined(L_df_to_sf)
++SFtype
++df_to_sf (DFtype arg_a)
++{
++  fp_number_type in;
++  USItype sffrac;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  sffrac = in.fraction.ll >> F_D_BITOFF;
++
++  /* We set the lowest guard bit in SFFRAC if we discarded any non
++     zero bits.  */
++  if ((in.fraction.ll & (((USItype) 1 << F_D_BITOFF) - 1)) != 0)
++    sffrac |= 1;
++
++  return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
++}
++#endif /* L_df_to_sf */
++
++#if defined(L_df_to_tf) && defined(TMODES) \
++    && !defined(FLOAT) && !defined(TFLOAT)
++TFtype
++df_to_tf (DFtype arg_a)
++{
++  fp_number_type in;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  return __make_tp (in.class, in.sign, in.normal_exp,
++                  ((UTItype) in.fraction.ll) << D_T_BITOFF);
++}
++#endif /* L_sf_to_df */
++
++#ifdef TFLOAT
++#if defined(L_make_tf)
++TFtype
++__make_tp(fp_class_type class,
++           unsigned int sign,
++           int exp, 
++           UTItype frac)
++{
++  fp_number_type in;
++
++  in.class = class;
++  in.sign = sign;
++  in.normal_exp = exp;
++  in.fraction.ll = frac;
++  return pack_d (&in);
++}
++#endif /* L_make_tf */
++
++#if defined(L_tf_to_df)
++DFtype
++tf_to_df (TFtype arg_a)
++{
++  fp_number_type in;
++  UDItype sffrac;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  sffrac = in.fraction.ll >> D_T_BITOFF;
++
++  /* We set the lowest guard bit in SFFRAC if we discarded any non
++     zero bits.  */
++  if ((in.fraction.ll & (((UTItype) 1 << D_T_BITOFF) - 1)) != 0)
++    sffrac |= 1;
++
++  return __make_dp (in.class, in.sign, in.normal_exp, sffrac);
++}
++#endif /* L_tf_to_df */
++
++#if defined(L_tf_to_sf)
++SFtype
++tf_to_sf (TFtype arg_a)
++{
++  fp_number_type in;
++  USItype sffrac;
++  FLO_union_type au;
++
++  au.value = arg_a;
++  unpack_d (&au, &in);
++
++  sffrac = in.fraction.ll >> F_T_BITOFF;
++
++  /* We set the lowest guard bit in SFFRAC if we discarded any non
++     zero bits.  */
++  if ((in.fraction.ll & (((UTItype) 1 << F_T_BITOFF) - 1)) != 0)
++    sffrac |= 1;
++
++  return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
++}
++#endif /* L_tf_to_sf */
++#endif /* TFLOAT */
++
++#endif /* ! FLOAT */
++#endif /* !EXTENDED_FLOAT_STUBS */
+--- ./gcc/gcc/libgcc2.c
++++ ./gcc/gcc/libgcc2.c
+@@ -0,0 +1,1669 @@
++/* More subroutines needed by GCC output code on some machines.  */
++/* Compile this one with gcc.  */
++/* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
++   2000, 2001, 2002, 2003  Free Software Foundation, Inc.
++
++This file is part of GCC.
++
++GCC is free software; you can redistribute it and/or modify it under
++the terms of the GNU General Public License as published by the Free
++Software Foundation; either version 2, or (at your option) any later
++version.
++
++In addition to the permissions in the GNU General Public License, the
++Free Software Foundation gives you unlimited permission to link the
++compiled version of this file into combinations with other programs,
++and to distribute those combinations without any restriction coming
++from the use of this file.  (The General Public License restrictions
++do apply in other respects; for example, they cover modification of
++the file, and distribution when not linked into a combine
++executable.)
++
++GCC is distributed in the hope that it will be useful, but WITHOUT ANY
++WARRANTY; without even the implied warranty of MERCHANTABILITY or
++FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
++for more details.
++
++You should have received a copy of the GNU General Public License
++along with GCC; see the file COPYING.  If not, write to the Free
++Software Foundation, 59 Temple Place - Suite 330, Boston, MA
++02111-1307, USA.  */
++
++
++/* We include auto-host.h here to get HAVE_GAS_HIDDEN.  This is
++   supposedly valid even though this is a "target" file.  */
++#include "auto-host.h"
++
++/* It is incorrect to include config.h here, because this file is being
++   compiled for the target, and hence definitions concerning only the host
++   do not apply.  */
++#include "tconfig.h"
++#include "tsystem.h"
++#include "coretypes.h"
++#include "tm.h"
++
++/* Don't use `fancy_abort' here even if config.h says to use it.  */
++#ifdef abort
++#undef abort
++#endif
++
++#ifdef HAVE_GAS_HIDDEN
++#define ATTRIBUTE_HIDDEN  __attribute__ ((__visibility__ ("hidden")))
++#else
++#define ATTRIBUTE_HIDDEN
++#endif
++
++#include "libgcc2.h"
++\f
++#ifdef DECLARE_LIBRARY_RENAMES
++  DECLARE_LIBRARY_RENAMES
++#endif
++
++#if defined (L_negdi2)
++DWtype
++__negdi2 (DWtype u)
++{
++  const DWunion uu = {.ll = u};
++  const DWunion w = { {.low = -uu.s.low,
++                     .high = -uu.s.high - ((UWtype) -uu.s.low > 0) } };
++
++  return w.ll;
++}
++#endif
++
++#ifdef L_addvsi3
++Wtype
++__addvsi3 (Wtype a, Wtype b)
++{
++  const Wtype w = a + b;
++
++  if (b >= 0 ? w < a : w > a)
++    abort ();
++
++  return w;
++}
++#endif
++\f
++#ifdef L_addvdi3
++DWtype
++__addvdi3 (DWtype a, DWtype b)
++{
++  const DWtype w = a + b;
++
++  if (b >= 0 ? w < a : w > a)
++    abort ();
++
++  return w;
++}
++#endif
++\f
++#ifdef L_subvsi3
++Wtype
++__subvsi3 (Wtype a, Wtype b)
++{
++  const DWtype w = a - b;
++
++  if (b >= 0 ? w > a : w < a)
++    abort ();
++
++  return w;
++}
++#endif
++\f
++#ifdef L_subvdi3
++DWtype
++__subvdi3 (DWtype a, DWtype b)
++{
++  const DWtype w = a - b;
++
++  if (b >= 0 ? w > a : w < a)
++    abort ();
++
++  return w;
++}
++#endif
++\f
++#ifdef L_mulvsi3
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++Wtype
++__mulvsi3 (Wtype a, Wtype b)
++{
++  const DWtype w = (DWtype) a * (DWtype) b;
++
++  if (((a >= 0) == (b >= 0))
++      ? (UDWtype) w > (UDWtype) (((DWtype) 1 << (WORD_SIZE - 1)) - 1)
++      : (UDWtype) w < (UDWtype) ((DWtype) -1 << (WORD_SIZE - 1)))
++    abort ();
++
++  return w;
++}
++#endif
++\f
++#ifdef L_negvsi2
++Wtype
++__negvsi2 (Wtype a)
++{
++  const Wtype w = -a;
++
++  if (a >= 0 ? w > 0 : w < 0)
++    abort ();
++
++   return w;
++}
++#endif
++\f
++#ifdef L_negvdi2
++DWtype
++__negvdi2 (DWtype a)
++{
++  const DWtype w = -a;
++
++  if (a >= 0 ? w > 0 : w < 0)
++    abort ();
++
++  return w;
++}
++#endif
++\f
++#ifdef L_absvsi2
++Wtype
++__absvsi2 (Wtype a)
++{
++  Wtype w = a;
++
++  if (a < 0)
++#ifdef L_negvsi2
++    w = __negvsi2 (a);
++#else
++    w = -a;
++
++  if (w < 0)
++    abort ();
++#endif
++
++   return w;
++}
++#endif
++\f
++#ifdef L_absvdi2
++DWtype
++__absvdi2 (DWtype a)
++{
++  DWtype w = a;
++
++  if (a < 0)
++#ifdef L_negvdi2
++    w = __negvdi2 (a);
++#else
++    w = -a;
++
++  if (w < 0)
++    abort ();
++#endif
++
++  return w;
++}
++#endif
++\f
++#ifdef L_mulvdi3
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++DWtype
++__mulvdi3 (DWtype u, DWtype v)
++{
++  /* The unchecked multiplication needs 3 Wtype x Wtype multiplications,
++     but the checked multiplication needs only two.  */
++  const DWunion uu = {.ll = u};
++  const DWunion vv = {.ll = v};
++
++  if (__builtin_expect (uu.s.high == uu.s.low >> (WORD_SIZE - 1), 1))
++    {
++      /* u fits in a single Wtype.  */
++      if (__builtin_expect (vv.s.high == vv.s.low >> (WORD_SIZE - 1), 1))
++      {
++        /* v fits in a single Wtype as well.  */
++        /* A single multiplication.  No overflow risk.  */
++        return (DWtype) uu.s.low * (DWtype) vv.s.low;
++      }
++      else
++      {
++        /* Two multiplications.  */
++        DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
++                      * (UDWtype) (UWtype) vv.s.low};
++        DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.low
++                      * (UDWtype) (UWtype) vv.s.high};
++
++        if (vv.s.high < 0)
++          w1.s.high -= uu.s.low;
++        if (uu.s.low < 0)
++          w1.ll -= vv.ll;
++        w1.ll += (UWtype) w0.s.high;
++        if (__builtin_expect (w1.s.high == w1.s.low >> (WORD_SIZE - 1), 1))
++          {
++            w0.s.high = w1.s.low;
++            return w0.ll;
++          }
++      }
++    }
++  else
++    {
++      if (__builtin_expect (vv.s.high == vv.s.low >> (WORD_SIZE - 1), 1))
++      {
++        /* v fits into a single Wtype.  */
++        /* Two multiplications.  */
++        DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
++                      * (UDWtype) (UWtype) vv.s.low};
++        DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.high
++                      * (UDWtype) (UWtype) vv.s.low};
++
++        if (uu.s.high < 0)
++          w1.s.high -= vv.s.low;
++        if (vv.s.low < 0)
++          w1.ll -= uu.ll;
++        w1.ll += (UWtype) w0.s.high;
++        if (__builtin_expect (w1.s.high == w1.s.low >> (WORD_SIZE - 1), 1))
++          {
++            w0.s.high = w1.s.low;
++            return w0.ll;
++          }
++      }
++      else
++      {
++        /* A few sign checks and a single multiplication.  */
++        if (uu.s.high >= 0)
++          {
++            if (vv.s.high >= 0)
++              {
++                if (uu.s.high == 0 && vv.s.high == 0)
++                  {
++                    const DWtype w = (UDWtype) (UWtype) uu.s.low
++                      * (UDWtype) (UWtype) vv.s.low;
++                    if (__builtin_expect (w >= 0, 1))
++                      return w;
++                  }
++              }
++            else
++              {
++                if (uu.s.high == 0 && vv.s.high == (Wtype) -1)
++                  {
++                    DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
++                                  * (UDWtype) (UWtype) vv.s.low};
++
++                    ww.s.high -= uu.s.low;
++                    if (__builtin_expect (ww.s.high < 0, 1))
++                      return ww.ll;
++                  }
++              }
++          }
++        else
++          {
++            if (vv.s.high >= 0)
++              {
++                if (uu.s.high == (Wtype) -1 && vv.s.high == 0)
++                  {
++                    DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
++                                  * (UDWtype) (UWtype) vv.s.low};
++
++                    ww.s.high -= vv.s.low;
++                    if (__builtin_expect (ww.s.high < 0, 1))
++                      return ww.ll;
++                  }
++              }
++            else
++              {
++                if (uu.s.high == (Wtype) -1 && vv.s.high == (Wtype) - 1)
++                  {
++                    DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
++                                  * (UDWtype) (UWtype) vv.s.low};
++
++                    ww.s.high -= uu.s.low;
++                    ww.s.high -= vv.s.low;
++                    if (__builtin_expect (ww.s.high >= 0, 1))
++                      return ww.ll;
++                  }
++              }
++          }
++      }
++    }
++
++  /* Overflow.  */
++  abort ();
++}
++#endif
++\f
++
++/* Unless shift functions are defined with full ANSI prototypes,
++   parameter b will be promoted to int if word_type is smaller than an int.  */
++#ifdef L_lshrdi3
++DWtype
++__lshrdi3 (DWtype u, word_type b)
++{
++  if (b == 0)
++    return u;
++
++  const DWunion uu = {.ll = u};
++  const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
++  DWunion w;
++
++  if (bm <= 0)
++    {
++      w.s.high = 0;
++      w.s.low = (UWtype) uu.s.high >> -bm;
++    }
++  else
++    {
++      const UWtype carries = (UWtype) uu.s.high << bm;
++
++      w.s.high = (UWtype) uu.s.high >> b;
++      w.s.low = ((UWtype) uu.s.low >> b) | carries;
++    }
++
++  return w.ll;
++}
++#endif
++
++#ifdef L_ashldi3
++DWtype
++__ashldi3 (DWtype u, word_type b)
++{
++  if (b == 0)
++    return u;
++
++  const DWunion uu = {.ll = u};
++  const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
++  DWunion w;
++
++  if (bm <= 0)
++    {
++      w.s.low = 0;
++      w.s.high = (UWtype) uu.s.low << -bm;
++    }
++  else
++    {
++      const UWtype carries = (UWtype) uu.s.low >> bm;
++
++      w.s.low = (UWtype) uu.s.low << b;
++      w.s.high = ((UWtype) uu.s.high << b) | carries;
++    }
++
++  return w.ll;
++}
++#endif
++
++#ifdef L_ashrdi3
++DWtype
++__ashrdi3 (DWtype u, word_type b)
++{
++  if (b == 0)
++    return u;
++
++  const DWunion uu = {.ll = u};
++  const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
++  DWunion w;
++
++  if (bm <= 0)
++    {
++      /* w.s.high = 1..1 or 0..0 */
++      w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
++      w.s.low = uu.s.high >> -bm;
++    }
++  else
++    {
++      const UWtype carries = (UWtype) uu.s.high << bm;
++
++      w.s.high = uu.s.high >> b;
++      w.s.low = ((UWtype) uu.s.low >> b) | carries;
++    }
++
++  return w.ll;
++}
++#endif
++\f
++#ifdef L_ffssi2
++#undef int
++extern int __ffsSI2 (UWtype u);
++int
++__ffsSI2 (UWtype u)
++{
++  UWtype count;
++
++  if (u == 0)
++    return 0;
++
++  count_trailing_zeros (count, u);
++  return count + 1;
++}
++#endif
++\f
++#ifdef L_ffsdi2
++#undef int
++extern int __ffsDI2 (DWtype u);
++int
++__ffsDI2 (DWtype u)
++{
++  const DWunion uu = {.ll = u};
++  UWtype word, count, add;
++
++  if (uu.s.low != 0)
++    word = uu.s.low, add = 0;
++  else if (uu.s.high != 0)
++    word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype);
++  else
++    return 0;
++
++  count_trailing_zeros (count, word);
++  return count + add + 1;
++}
++#endif
++\f
++#ifdef L_muldi3
++DWtype
++__muldi3 (DWtype u, DWtype v)
++{
++  const DWunion uu = {.ll = u};
++  const DWunion vv = {.ll = v};
++  DWunion w = {.ll = __umulsidi3 (uu.s.low, vv.s.low)};
++
++  w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
++             + (UWtype) uu.s.high * (UWtype) vv.s.low);
++
++  return w.ll;
++}
++#endif
++\f
++#if (defined (L_udivdi3) || defined (L_divdi3) || \
++     defined (L_umoddi3) || defined (L_moddi3))
++#if defined (sdiv_qrnnd)
++#define L_udiv_w_sdiv
++#endif
++#endif
++
++#ifdef L_udiv_w_sdiv
++#if defined (sdiv_qrnnd)
++#if (defined (L_udivdi3) || defined (L_divdi3) || \
++     defined (L_umoddi3) || defined (L_moddi3))
++static inline __attribute__ ((__always_inline__))
++#endif
++UWtype
++__udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
++{
++  UWtype q, r;
++  UWtype c0, c1, b1;
++
++  if ((Wtype) d >= 0)
++    {
++      if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
++      {
++        /* dividend, divisor, and quotient are nonnegative */
++        sdiv_qrnnd (q, r, a1, a0, d);
++      }
++      else
++      {
++        /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
++        sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
++        /* Divide (c1*2^32 + c0) by d */
++        sdiv_qrnnd (q, r, c1, c0, d);
++        /* Add 2^31 to quotient */
++        q += (UWtype) 1 << (W_TYPE_SIZE - 1);
++      }
++    }
++  else
++    {
++      b1 = d >> 1;                    /* d/2, between 2^30 and 2^31 - 1 */
++      c1 = a1 >> 1;                   /* A/2 */
++      c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
++
++      if (a1 < b1)                    /* A < 2^32*b1, so A/2 < 2^31*b1 */
++      {
++        sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
++
++        r = 2*r + (a0 & 1);           /* Remainder from A/(2*b1) */
++        if ((d & 1) != 0)
++          {
++            if (r >= q)
++              r = r - q;
++            else if (q - r <= d)
++              {
++                r = r - q + d;
++                q--;
++              }
++            else
++              {
++                r = r - q + 2*d;
++                q -= 2;
++              }
++          }
++      }
++      else if (c1 < b1)                       /* So 2^31 <= (A/2)/b1 < 2^32 */
++      {
++        c1 = (b1 - 1) - c1;
++        c0 = ~c0;                     /* logical NOT */
++
++        sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
++
++        q = ~q;                       /* (A/2)/b1 */
++        r = (b1 - 1) - r;
++
++        r = 2*r + (a0 & 1);           /* A/(2*b1) */
++
++        if ((d & 1) != 0)
++          {
++            if (r >= q)
++              r = r - q;
++            else if (q - r <= d)
++              {
++                r = r - q + d;
++                q--;
++              }
++            else
++              {
++                r = r - q + 2*d;
++                q -= 2;
++              }
++          }
++      }
++      else                            /* Implies c1 = b1 */
++      {                               /* Hence a1 = d - 1 = 2*b1 - 1 */
++        if (a0 >= -d)
++          {
++            q = -1;
++            r = a0 + d;
++          }
++        else
++          {
++            q = -2;
++            r = a0 + 2*d;
++          }
++      }
++    }
++
++  *rp = r;
++  return q;
++}
++#else
++/* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv.  */
++UWtype
++__udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
++             UWtype a1 __attribute__ ((__unused__)),
++             UWtype a0 __attribute__ ((__unused__)),
++             UWtype d __attribute__ ((__unused__)))
++{
++  return 0;
++}
++#endif
++#endif
++\f
++#if (defined (L_udivdi3) || defined (L_divdi3) || \
++     defined (L_umoddi3) || defined (L_moddi3))
++#define L_udivmoddi4
++#endif
++
++#ifdef L_clz
++const UQItype __clz_tab[] =
++{
++  0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
++  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
++  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
++  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
++  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
++  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
++  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
++  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
++};
++#endif
++\f
++#ifdef L_clzsi2
++#undef int
++extern int __clzSI2 (UWtype x);
++int
++__clzSI2 (UWtype x)
++{
++  Wtype ret;
++
++  count_leading_zeros (ret, x);
++
++  return ret;
++}
++#endif
++\f
++#ifdef L_clzdi2
++#undef int
++extern int __clzDI2 (UDWtype x);
++int
++__clzDI2 (UDWtype x)
++{
++  const DWunion uu = {.ll = x};
++  UWtype word;
++  Wtype ret, add;
++
++  if (uu.s.high)
++    word = uu.s.high, add = 0;
++  else
++    word = uu.s.low, add = W_TYPE_SIZE;
++
++  count_leading_zeros (ret, word);
++  return ret + add;
++}
++#endif
++\f
++#ifdef L_ctzsi2
++#undef int
++extern int __ctzSI2 (UWtype x);
++int
++__ctzSI2 (UWtype x)
++{
++  Wtype ret;
++
++  count_trailing_zeros (ret, x);
++
++  return ret;
++}
++#endif
++\f
++#ifdef L_ctzdi2
++#undef int
++extern int __ctzDI2 (UDWtype x);
++int
++__ctzDI2 (UDWtype x)
++{
++  const DWunion uu = {.ll = x};
++  UWtype word;
++  Wtype ret, add;
++
++  if (uu.s.low)
++    word = uu.s.low, add = 0;
++  else
++    word = uu.s.high, add = W_TYPE_SIZE;
++
++  count_trailing_zeros (ret, word);
++  return ret + add;
++}
++#endif
++
++#if (defined (L_popcountsi2) || defined (L_popcountdi2)       \
++     || defined (L_popcount_tab))
++extern const UQItype __popcount_tab[] ATTRIBUTE_HIDDEN;
++#endif
++
++#ifdef L_popcount_tab
++const UQItype __popcount_tab[] =
++{
++    0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
++    1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
++    1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
++    2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
++    1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
++    2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
++    2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
++    3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,
++};
++#endif
++\f
++#ifdef L_popcountsi2
++#undef int
++extern int __popcountSI2 (UWtype x);
++int
++__popcountSI2 (UWtype x)
++{
++  UWtype i, ret = 0;
++
++  for (i = 0; i < W_TYPE_SIZE; i += 8)
++    ret += __popcount_tab[(x >> i) & 0xff];
++
++  return ret;
++}
++#endif
++\f
++#ifdef L_popcountdi2
++#undef int
++extern int __popcountDI2 (UDWtype x);
++int
++__popcountDI2 (UDWtype x)
++{
++  UWtype i, ret = 0;
++
++  for (i = 0; i < 2*W_TYPE_SIZE; i += 8)
++    ret += __popcount_tab[(x >> i) & 0xff];
++
++  return ret;
++}
++#endif
++\f
++#ifdef L_paritysi2
++#undef int
++extern int __paritySI2 (UWtype x);
++int
++__paritySI2 (UWtype x)
++{
++#if W_TYPE_SIZE > 64
++# error "fill out the table"
++#endif
++#if W_TYPE_SIZE > 32
++  x ^= x >> 32;
++#endif
++#if W_TYPE_SIZE > 16
++  x ^= x >> 16;
++#endif
++  x ^= x >> 8;
++  x ^= x >> 4;
++  x &= 0xf;
++  return (0x6996 >> x) & 1;
++}
++#endif
++\f
++#ifdef L_paritydi2
++#undef int
++extern int __parityDI2 (UDWtype x);
++int
++__parityDI2 (UDWtype x)
++{
++  const DWunion uu = {.ll = x};
++  UWtype nx = uu.s.low ^ uu.s.high;
++
++#if W_TYPE_SIZE > 64
++# error "fill out the table"
++#endif
++#if W_TYPE_SIZE > 32
++  nx ^= nx >> 32;
++#endif
++#if W_TYPE_SIZE > 16
++  nx ^= nx >> 16;
++#endif
++  nx ^= nx >> 8;
++  nx ^= nx >> 4;
++  nx &= 0xf;
++  return (0x6996 >> nx) & 1;
++}
++#endif
++
++#ifdef L_udivmoddi4
++
++#if (defined (L_udivdi3) || defined (L_divdi3) || \
++     defined (L_umoddi3) || defined (L_moddi3))
++static inline __attribute__ ((__always_inline__))
++#endif
++UDWtype
++__udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
++{
++  const DWunion nn = {.ll = n};
++  const DWunion dd = {.ll = d};
++  DWunion rr;
++  UWtype d0, d1, n0, n1, n2;
++  UWtype q0, q1;
++  UWtype b, bm;
++
++  d0 = dd.s.low;
++  d1 = dd.s.high;
++  n0 = nn.s.low;
++  n1 = nn.s.high;
++
++#if !UDIV_NEEDS_NORMALIZATION
++  if (d1 == 0)
++    {
++      if (d0 > n1)
++      {
++        /* 0q = nn / 0D */
++
++        udiv_qrnnd (q0, n0, n1, n0, d0);
++        q1 = 0;
++
++        /* Remainder in n0.  */
++      }
++      else
++      {
++        /* qq = NN / 0d */
++
++        if (d0 == 0)
++          d0 = 1 / d0;        /* Divide intentionally by zero.  */
++
++        udiv_qrnnd (q1, n1, 0, n1, d0);
++        udiv_qrnnd (q0, n0, n1, n0, d0);
++
++        /* Remainder in n0.  */
++      }
++
++      if (rp != 0)
++      {
++        rr.s.low = n0;
++        rr.s.high = 0;
++        *rp = rr.ll;
++      }
++    }
++
++#else /* UDIV_NEEDS_NORMALIZATION */
++
++  if (d1 == 0)
++    {
++      if (d0 > n1)
++      {
++        /* 0q = nn / 0D */
++
++        count_leading_zeros (bm, d0);
++
++        if (bm != 0)
++          {
++            /* Normalize, i.e. make the most significant bit of the
++               denominator set.  */
++
++            d0 = d0 << bm;
++            n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
++            n0 = n0 << bm;
++          }
++
++        udiv_qrnnd (q0, n0, n1, n0, d0);
++        q1 = 0;
++
++        /* Remainder in n0 >> bm.  */
++      }
++      else
++      {
++        /* qq = NN / 0d */
++
++        if (d0 == 0)
++          d0 = 1 / d0;        /* Divide intentionally by zero.  */
++
++        count_leading_zeros (bm, d0);
++
++        if (bm == 0)
++          {
++            /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
++               conclude (the most significant bit of n1 is set) /\ (the
++               leading quotient digit q1 = 1).
++
++               This special case is necessary, not an optimization.
++               (Shifts counts of W_TYPE_SIZE are undefined.)  */
++
++            n1 -= d0;
++            q1 = 1;
++          }
++        else
++          {
++            /* Normalize.  */
++
++            b = W_TYPE_SIZE - bm;
++
++            d0 = d0 << bm;
++            n2 = n1 >> b;
++            n1 = (n1 << bm) | (n0 >> b);
++            n0 = n0 << bm;
++
++            udiv_qrnnd (q1, n1, n2, n1, d0);
++          }
++
++        /* n1 != d0...  */
++
++        udiv_qrnnd (q0, n0, n1, n0, d0);
++
++        /* Remainder in n0 >> bm.  */
++      }
++
++      if (rp != 0)
++      {
++        rr.s.low = n0 >> bm;
++        rr.s.high = 0;
++        *rp = rr.ll;
++      }
++    }
++#endif /* UDIV_NEEDS_NORMALIZATION */
++
++  else
++    {
++      if (d1 > n1)
++      {
++        /* 00 = nn / DD */
++
++        q0 = 0;
++        q1 = 0;
++
++        /* Remainder in n1n0.  */
++        if (rp != 0)
++          {
++            rr.s.low = n0;
++            rr.s.high = n1;
++            *rp = rr.ll;
++          }
++      }
++      else
++      {
++        /* 0q = NN / dd */
++
++        count_leading_zeros (bm, d1);
++        if (bm == 0)
++          {
++            /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
++               conclude (the most significant bit of n1 is set) /\ (the
++               quotient digit q0 = 0 or 1).
++
++               This special case is necessary, not an optimization.  */
++
++            /* The condition on the next line takes advantage of that
++               n1 >= d1 (true due to program flow).  */
++            if (n1 > d1 || n0 >= d0)
++              {
++                q0 = 1;
++                sub_ddmmss (n1, n0, n1, n0, d1, d0);
++              }
++            else
++              q0 = 0;
++
++            q1 = 0;
++
++            if (rp != 0)
++              {
++                rr.s.low = n0;
++                rr.s.high = n1;
++                *rp = rr.ll;
++              }
++          }
++        else
++          {
++            UWtype m1, m0;
++            /* Normalize.  */
++
++            b = W_TYPE_SIZE - bm;
++
++            d1 = (d1 << bm) | (d0 >> b);
++            d0 = d0 << bm;
++            n2 = n1 >> b;
++            n1 = (n1 << bm) | (n0 >> b);
++            n0 = n0 << bm;
++
++            udiv_qrnnd (q0, n1, n2, n1, d1);
++            umul_ppmm (m1, m0, q0, d0);
++
++            if (m1 > n1 || (m1 == n1 && m0 > n0))
++              {
++                q0--;
++                sub_ddmmss (m1, m0, m1, m0, d1, d0);
++              }
++
++            q1 = 0;
++
++            /* Remainder in (n1n0 - m1m0) >> bm.  */
++            if (rp != 0)
++              {
++                sub_ddmmss (n1, n0, n1, n0, m1, m0);
++                rr.s.low = (n1 << b) | (n0 >> bm);
++                rr.s.high = n1 >> bm;
++                *rp = rr.ll;
++              }
++          }
++      }
++    }
++
++  const DWunion ww = {{.low = q0, .high = q1}};
++  return ww.ll;
++}
++#endif
++
++#ifdef L_divdi3
++DWtype
++__divdi3 (DWtype u, DWtype v)
++{
++  word_type c = 0;
++  DWunion uu = {.ll = u};
++  DWunion vv = {.ll = v};
++  DWtype w;
++
++  if (uu.s.high < 0)
++    c = ~c,
++    uu.ll = -uu.ll;
++  if (vv.s.high < 0)
++    c = ~c,
++    vv.ll = -vv.ll;
++
++  w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
++  if (c)
++    w = -w;
++
++  return w;
++}
++#endif
++
++#ifdef L_moddi3
++DWtype
++__moddi3 (DWtype u, DWtype v)
++{
++  word_type c = 0;
++  DWunion uu = {.ll = u};
++  DWunion vv = {.ll = v};
++  DWtype w;
++
++  if (uu.s.high < 0)
++    c = ~c,
++    uu.ll = -uu.ll;
++  if (vv.s.high < 0)
++    vv.ll = -vv.ll;
++
++  (void) __udivmoddi4 (uu.ll, vv.ll, &w);
++  if (c)
++    w = -w;
++
++  return w;
++}
++#endif
++
++#ifdef L_umoddi3
++UDWtype
++__umoddi3 (UDWtype u, UDWtype v)
++{
++  UDWtype w;
++
++  (void) __udivmoddi4 (u, v, &w);
++
++  return w;
++}
++#endif
++
++#ifdef L_udivdi3
++UDWtype
++__udivdi3 (UDWtype n, UDWtype d)
++{
++  return __udivmoddi4 (n, d, (UDWtype *) 0);
++}
++#endif
++\f
++#ifdef L_cmpdi2
++word_type
++__cmpdi2 (DWtype a, DWtype b)
++{
++  const DWunion au = {.ll = a};
++  const DWunion bu = {.ll = b};
++
++  if (au.s.high < bu.s.high)
++    return 0;
++  else if (au.s.high > bu.s.high)
++    return 2;
++  if ((UWtype) au.s.low < (UWtype) bu.s.low)
++    return 0;
++  else if ((UWtype) au.s.low > (UWtype) bu.s.low)
++    return 2;
++  return 1;
++}
++#endif
++
++#ifdef L_ucmpdi2
++word_type
++__ucmpdi2 (DWtype a, DWtype b)
++{
++  const DWunion au = {.ll = a};
++  const DWunion bu = {.ll = b};
++
++  if ((UWtype) au.s.high < (UWtype) bu.s.high)
++    return 0;
++  else if ((UWtype) au.s.high > (UWtype) bu.s.high)
++    return 2;
++  if ((UWtype) au.s.low < (UWtype) bu.s.low)
++    return 0;
++  else if ((UWtype) au.s.low > (UWtype) bu.s.low)
++    return 2;
++  return 1;
++}
++#endif
++\f
++#if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
++
++DWtype
++__fixunstfDI (TFtype a)
++{
++  if (a < 0)
++    return 0;
++
++  /* Compute high word of result, as a flonum.  */
++  const TFtype b = (a / HIGH_WORD_COEFF);
++  /* Convert that to fixed (but not to DWtype!),
++     and shift it into the high word.  */
++  UDWtype v = (UWtype) b;
++  v <<= WORD_SIZE;
++  /* Remove high part from the TFtype, leaving the low part as flonum.  */
++  a -= (TFtype)v;
++  /* Convert that to fixed (but not to DWtype!) and add it in.
++     Sometimes A comes out negative.  This is significant, since
++     A has more bits than a long int does.  */
++  if (a < 0)
++    v -= (UWtype) (- a);
++  else
++    v += (UWtype) a;
++  return v;
++}
++#endif
++
++#if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
++DWtype
++__fixtfdi (TFtype a)
++{
++  if (a < 0)
++    return - __fixunstfDI (-a);
++  return __fixunstfDI (a);
++}
++#endif
++
++#if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
++
++DWtype
++__fixunsxfDI (XFtype a)
++{
++  if (a < 0)
++    return 0;
++
++  /* Compute high word of result, as a flonum.  */
++  const XFtype b = (a / HIGH_WORD_COEFF);
++  /* Convert that to fixed (but not to DWtype!),
++     and shift it into the high word.  */
++  UDWtype v = (UWtype) b;
++  v <<= WORD_SIZE;
++  /* Remove high part from the XFtype, leaving the low part as flonum.  */
++  a -= (XFtype)v;
++  /* Convert that to fixed (but not to DWtype!) and add it in.
++     Sometimes A comes out negative.  This is significant, since
++     A has more bits than a long int does.  */
++  if (a < 0)
++    v -= (UWtype) (- a);
++  else
++    v += (UWtype) a;
++  return v;
++}
++#endif
++
++#if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
++DWtype
++__fixxfdi (XFtype a)
++{
++  if (a < 0)
++    return - __fixunsxfDI (-a);
++  return __fixunsxfDI (a);
++}
++#endif
++
++#ifdef L_fixunsdfdi
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
++
++DWtype
++__fixunsdfDI (DFtype a)
++{
++  /* Get high part of result.  The division here will just moves the radix
++     point and will not cause any rounding.  Then the conversion to integral
++     type chops result as desired.  */
++  const UWtype hi = a / HIGH_WORD_COEFF;
++
++  /* Get low part of result.  Convert `hi' to floating type and scale it back,
++     then subtract this from the number being converted.  This leaves the low
++     part.  Convert that to integral type.  */
++  const UWtype lo = (a - ((DFtype) hi) * HIGH_WORD_COEFF);
++
++  /* Assemble result from the two parts.  */
++  return ((UDWtype) hi << WORD_SIZE) | lo;
++}
++#endif
++
++#ifdef L_fixdfdi
++DWtype
++__fixdfdi (DFtype a)
++{
++  if (a < 0)
++    return - __fixunsdfDI (-a);
++  return __fixunsdfDI (a);
++}
++#endif
++
++#ifdef L_fixunssfdi
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
++
++DWtype
++__fixunssfDI (SFtype original_a)
++{
++  /* Convert the SFtype to a DFtype, because that is surely not going
++     to lose any bits.  Some day someone else can write a faster version
++     that avoids converting to DFtype, and verify it really works right.  */
++  const DFtype a = original_a;
++
++  /* Get high part of result.  The division here will just moves the radix
++     point and will not cause any rounding.  Then the conversion to integral
++     type chops result as desired.  */
++  const UWtype hi = a / HIGH_WORD_COEFF;
++
++  /* Get low part of result.  Convert `hi' to floating type and scale it back,
++     then subtract this from the number being converted.  This leaves the low
++     part.  Convert that to integral type.  */
++  const UWtype lo = (a - ((DFtype) hi) * HIGH_WORD_COEFF);
++
++  /* Assemble result from the two parts.  */
++  return ((UDWtype) hi << WORD_SIZE) | lo;
++}
++#endif
++
++#ifdef L_fixsfdi
++DWtype
++__fixsfdi (SFtype a)
++{
++  if (a < 0)
++    return - __fixunssfDI (-a);
++  return __fixunssfDI (a);
++}
++#endif
++
++#if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
++#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
++
++XFtype
++__floatdixf (DWtype u)
++{
++  XFtype d = (Wtype) (u >> WORD_SIZE);
++  d *= HIGH_HALFWORD_COEFF;
++  d *= HIGH_HALFWORD_COEFF;
++  d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
++
++  return d;
++}
++#endif
++
++#if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
++#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
++
++TFtype
++__floatditf (DWtype u)
++{
++  TFtype d = (Wtype) (u >> WORD_SIZE);
++  d *= HIGH_HALFWORD_COEFF;
++  d *= HIGH_HALFWORD_COEFF;
++  d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
++
++  return d;
++}
++#endif
++
++#ifdef L_floatdidf
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
++#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
++
++DFtype
++__floatdidf (DWtype u)
++{
++  DFtype d = (Wtype) (u >> WORD_SIZE);
++  d *= HIGH_HALFWORD_COEFF;
++  d *= HIGH_HALFWORD_COEFF;
++  d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
++
++  return d;
++}
++#endif
++
++#ifdef L_floatdisf
++#define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
++#define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
++#define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
++
++#define DI_SIZE (sizeof (DWtype) * BITS_PER_UNIT)
++#define DF_SIZE DBL_MANT_DIG
++#define SF_SIZE FLT_MANT_DIG
++
++SFtype
++__floatdisf (DWtype u)
++{
++  /* Protect against double-rounding error.
++     Represent any low-order bits, that might be truncated in DFmode,
++     by a bit that won't be lost.  The bit can go in anywhere below the
++     rounding position of the SFmode.  A fixed mask and bit position
++     handles all usual configurations.  It doesn't handle the case
++     of 128-bit DImode, however.  */
++  if (DF_SIZE < DI_SIZE
++      && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
++    {
++#define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
++      if (! (- ((DWtype) 1 << DF_SIZE) < u
++           && u < ((DWtype) 1 << DF_SIZE)))
++      {
++        if ((UDWtype) u & (REP_BIT - 1))
++          {
++            u &= ~ (REP_BIT - 1);
++            u |= REP_BIT;
++          }
++      }
++    }
++  /* Do the calculation in DFmode
++     so that we don't lose any of the precision of the high word
++     while multiplying it.  */
++  DFtype f = (Wtype) (u >> WORD_SIZE);
++  f *= HIGH_HALFWORD_COEFF;
++  f *= HIGH_HALFWORD_COEFF;
++  f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
++
++  return (SFtype) f;
++}
++#endif
++
++#if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
++/* Reenable the normal types, in case limits.h needs them.  */
++#undef char
++#undef short
++#undef int
++#undef long
++#undef unsigned
++#undef float
++#undef double
++#undef MIN
++#undef MAX
++#include <limits.h>
++
++UWtype
++__fixunsxfSI (XFtype a)
++{
++  if (a >= - (DFtype) Wtype_MIN)
++    return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
++  return (Wtype) a;
++}
++#endif
++
++#ifdef L_fixunsdfsi
++/* Reenable the normal types, in case limits.h needs them.  */
++#undef char
++#undef short
++#undef int
++#undef long
++#undef unsigned
++#undef float
++#undef double
++#undef MIN
++#undef MAX
++#include <limits.h>
++
++UWtype
++__fixunsdfSI (DFtype a)
++{
++  if (a >= - (DFtype) Wtype_MIN)
++    return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
++  return (Wtype) a;
++}
++#endif
++
++#ifdef L_fixunssfsi
++/* Reenable the normal types, in case limits.h needs them.  */
++#undef char
++#undef short
++#undef int
++#undef long
++#undef unsigned
++#undef float
++#undef double
++#undef MIN
++#undef MAX
++#include <limits.h>
++
++UWtype
++__fixunssfSI (SFtype a)
++{
++  if (a >= - (SFtype) Wtype_MIN)
++    return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
++  return (Wtype) a;
++}
++#endif
++\f
++/* From here on down, the routines use normal data types.  */
++
++#define SItype bogus_type
++#define USItype bogus_type
++#define DItype bogus_type
++#define UDItype bogus_type
++#define SFtype bogus_type
++#define DFtype bogus_type
++#undef Wtype
++#undef UWtype
++#undef HWtype
++#undef UHWtype
++#undef DWtype
++#undef UDWtype
++
++#undef char
++#undef short
++#undef int
++#undef long
++#undef unsigned
++#undef float
++#undef double
++\f
++#ifdef L__gcc_bcmp
++
++/* Like bcmp except the sign is meaningful.
++   Result is negative if S1 is less than S2,
++   positive if S1 is greater, 0 if S1 and S2 are equal.  */
++
++int
++__gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
++{
++  while (size > 0)
++    {
++      const unsigned char c1 = *s1++, c2 = *s2++;
++      if (c1 != c2)
++      return c1 - c2;
++      size--;
++    }
++  return 0;
++}
++
++#endif
++\f
++/* __eprintf used to be used by GCC's private version of <assert.h>.
++   We no longer provide that header, but this routine remains in libgcc.a
++   for binary backward compatibility.  Note that it is not included in
++   the shared version of libgcc.  */
++#ifdef L_eprintf
++#ifndef inhibit_libc
++
++#undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
++#include <stdio.h>
++
++void
++__eprintf (const char *string, const char *expression,
++         unsigned int line, const char *filename)
++{
++  fprintf (stderr, string, expression, line, filename);
++  fflush (stderr);
++  abort ();
++}
++
++#endif
++#endif
++
++\f
++#ifdef L_clear_cache
++/* Clear part of an instruction cache.  */
++
++void
++__clear_cache (char *beg __attribute__((__unused__)),
++             char *end __attribute__((__unused__)))
++{
++#ifdef CLEAR_INSN_CACHE
++  CLEAR_INSN_CACHE (beg, end);
++#endif /* CLEAR_INSN_CACHE */
++}
++
++#endif /* L_clear_cache */
++\f
++#ifdef L_trampoline
++
++/* Jump to a trampoline, loading the static chain address.  */
++
++#if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
++
++long
++getpagesize (void)
++{
++#ifdef _ALPHA_
++  return 8192;
++#else
++  return 4096;
++#endif
++}
++
++#ifdef __i386__
++extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
++#endif
++
++int
++mprotect (char *addr, int len, int prot)
++{
++  int np, op;
++
++  if (prot == 7)
++    np = 0x40;
++  else if (prot == 5)
++    np = 0x20;
++  else if (prot == 4)
++    np = 0x10;
++  else if (prot == 3)
++    np = 0x04;
++  else if (prot == 1)
++    np = 0x02;
++  else if (prot == 0)
++    np = 0x01;
++
++  if (VirtualProtect (addr, len, np, &op))
++    return 0;
++  else
++    return -1;
++}
++
++#endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
++
++#ifdef TRANSFER_FROM_TRAMPOLINE
++TRANSFER_FROM_TRAMPOLINE
++#endif
++#endif /* L_trampoline */
++\f
++#ifndef __CYGWIN__
++#ifdef L__main
++
++#include "gbl-ctors.h"
++/* Some systems use __main in a way incompatible with its use in gcc, in these
++   cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
++   give the same symbol without quotes for an alternative entry point.  You
++   must define both, or neither.  */
++#ifndef NAME__MAIN
++#define NAME__MAIN "__main"
++#define SYMBOL__MAIN __main
++#endif
++
++#ifdef INIT_SECTION_ASM_OP
++#undef HAS_INIT_SECTION
++#define HAS_INIT_SECTION
++#endif
++
++#if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
++
++/* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
++   code to run constructors.  In that case, we need to handle EH here, too.  */
++
++#ifdef EH_FRAME_SECTION_NAME
++#include "unwind-dw2-fde.h"
++extern unsigned char __EH_FRAME_BEGIN__[];
++#endif
++
++/* Run all the global destructors on exit from the program.  */
++
++void
++__do_global_dtors (void)
++{
++#ifdef DO_GLOBAL_DTORS_BODY
++  DO_GLOBAL_DTORS_BODY;
++#else
++  static func_ptr *p = __DTOR_LIST__ + 1;
++  while (*p)
++    {
++      p++;
++      (*(p-1)) ();
++    }
++#endif
++#if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
++  {
++    static int completed = 0;
++    if (! completed)
++      {
++      completed = 1;
++      __deregister_frame_info (__EH_FRAME_BEGIN__);
++      }
++  }
++#endif
++}
++#endif
++
++#ifndef HAS_INIT_SECTION
++/* Run all the global constructors on entry to the program.  */
++
++void
++__do_global_ctors (void)
++{
++#ifdef EH_FRAME_SECTION_NAME
++  {
++    static struct object object;
++    __register_frame_info (__EH_FRAME_BEGIN__, &object);
++  }
++#endif
++  DO_GLOBAL_CTORS_BODY;
++  atexit (__do_global_dtors);
++}
++#endif /* no HAS_INIT_SECTION */
++
++#if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
++/* Subroutine called automatically by `main'.
++   Compiling a global function named `main'
++   produces an automatic call to this function at the beginning.
++
++   For many systems, this routine calls __do_global_ctors.
++   For systems which support a .init section we use the .init section
++   to run __do_global_ctors, so we need not do anything here.  */
++
++extern void SYMBOL__MAIN (void);
++void
++SYMBOL__MAIN (void)
++{
++  /* Support recursive calls to `main': run initializers just once.  */
++  static int initialized;
++  if (! initialized)
++    {
++      initialized = 1;
++      __do_global_ctors ();
++    }
++}
++#endif /* no HAS_INIT_SECTION or INVOKE__main */
++
++#endif /* L__main */
++#endif /* __CYGWIN__ */
++\f
++#ifdef L_ctors
++
++#include "gbl-ctors.h"
++
++/* Provide default definitions for the lists of constructors and
++   destructors, so that we don't get linker errors.  These symbols are
++   intentionally bss symbols, so that gld and/or collect will provide
++   the right values.  */
++
++/* We declare the lists here with two elements each,
++   so that they are valid empty lists if no other definition is loaded.
++
++   If we are using the old "set" extensions to have the gnu linker
++   collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
++   must be in the bss/common section.
++
++   Long term no port should use those extensions.  But many still do.  */
++#if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
++#if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
++func_ptr __CTOR_LIST__[2] = {0, 0};
++func_ptr __DTOR_LIST__[2] = {0, 0};
++#else
++func_ptr __CTOR_LIST__[2];
++func_ptr __DTOR_LIST__[2];
++#endif
++#endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
++#endif /* L_ctors */
++
+--- ./gcc/gcc/libgcc2.h
++++ ./gcc/gcc/libgcc2.h
+@@ -0,0 +1,310 @@
++/* Header file for libgcc2.c.  */
++/* Copyright (C) 2000, 2001
++   Free Software Foundation, Inc.
++
++This file is part of GCC.
++
++GCC is free software; you can redistribute it and/or modify it under
++the terms of the GNU General Public License as published by the Free
++Software Foundation; either version 2, or (at your option) any later
++version.
++
++GCC is distributed in the hope that it will be useful, but WITHOUT ANY
++WARRANTY; without even the implied warranty of MERCHANTABILITY or
++FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
++for more details.
++
++You should have received a copy of the GNU General Public License
++along with GCC; see the file COPYING.  If not, write to the Free
++Software Foundation, 59 Temple Place - Suite 330, Boston, MA
++02111-1307, USA.  */
++
++/* As a special exception, if you link this library with other files,
++   some of which are compiled with GCC, to produce an executable,
++   this library does not by itself cause the resulting executable
++   to be covered by the GNU General Public License.
++   This exception does not however invalidate any other reasons why
++   the executable file might be covered by the GNU General Public License.  */
++
++
++#ifndef GCC_LIBGCC2_H
++#define GCC_LIBGCC2_H
++
++extern int __gcc_bcmp (const unsigned char *, const unsigned char *, size_t);
++extern void __clear_cache (char *, char *);
++extern void __eprintf (const char *, const char *, unsigned int, const char *)
++  __attribute__ ((__noreturn__));
++
++struct exception_descriptor;
++extern short int __get_eh_table_language (struct exception_descriptor *);
++extern short int __get_eh_table_version (struct exception_descriptor *);
++
++/* Permit the tm.h file to select the endianness to use just for this
++   file.  This is used when the endianness is determined when the
++   compiler is run.  */
++
++#ifndef LIBGCC2_WORDS_BIG_ENDIAN
++#define LIBGCC2_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN
++#endif
++
++#ifndef LIBGCC2_LONG_DOUBLE_TYPE_SIZE
++#define LIBGCC2_LONG_DOUBLE_TYPE_SIZE LONG_DOUBLE_TYPE_SIZE
++#endif
++
++#ifndef MIN_UNITS_PER_WORD
++#define MIN_UNITS_PER_WORD UNITS_PER_WORD
++#endif
++
++/* In the first part of this file, we are interfacing to calls generated
++   by the compiler itself.  These calls pass values into these routines
++   which have very specific modes (rather than very specific types), and
++   these compiler-generated calls also expect any return values to have
++   very specific modes (rather than very specific types).  Thus, we need
++   to avoid using regular C language type names in this part of the file
++   because the sizes for those types can be configured to be anything.
++   Instead we use the following special type names.  */
++
++typedef                int QItype     __attribute__ ((mode (QI)));
++typedef unsigned int UQItype  __attribute__ ((mode (QI)));
++typedef                int HItype     __attribute__ ((mode (HI)));
++typedef unsigned int UHItype  __attribute__ ((mode (HI)));
++#if MIN_UNITS_PER_WORD > 1
++/* These typedefs are usually forbidden on dsp's with UNITS_PER_WORD 1.  */
++typedef        int SItype     __attribute__ ((mode (SI)));
++typedef unsigned int USItype  __attribute__ ((mode (SI)));
++#if LONG_LONG_TYPE_SIZE > 32
++/* These typedefs are usually forbidden on archs with UNITS_PER_WORD 2.  */
++typedef                int DItype     __attribute__ ((mode (DI)));
++typedef unsigned int UDItype  __attribute__ ((mode (DI)));
++#if MIN_UNITS_PER_WORD > 4
++/* These typedefs are usually forbidden on archs with UNITS_PER_WORD 4.  */
++typedef                int TItype     __attribute__ ((mode (TI)));
++typedef unsigned int UTItype  __attribute__ ((mode (TI)));
++#endif
++#endif
++#endif
++
++#if BITS_PER_UNIT == 8
++
++typedef       float SFtype    __attribute__ ((mode (SF)));
++typedef               float DFtype    __attribute__ ((mode (DF)));
++
++#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
++typedef               float XFtype    __attribute__ ((mode (XF)));
++#endif
++#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
++typedef               float TFtype    __attribute__ ((mode (TF)));
++#endif
++
++#else /* BITS_PER_UNIT != 8 */
++
++/* On dsp's there are usually qf/hf/tqf modes used instead of the above.
++   For now we don't support them in libgcc2.c.  */
++
++#undef L_fixdfdi
++#undef L_fixsfdi
++#undef L_fixtfdi
++#undef L_fixunsdfdi
++#undef L_fixunsdfsi
++#undef L_fixunssfdi
++#undef L_fixunssfsi
++#undef L_fixunstfdi
++#undef L_fixunsxfdi
++#undef L_fixunsxfsi
++#undef L_fixxfdi
++#undef L_floatdidf
++#undef L_floatdisf
++#undef L_floatditf
++#undef L_floatdixf
++
++#endif /* BITS_PER_UNIT != 8 */
++
++typedef int word_type __attribute__ ((mode (__word__)));
++
++/* Make sure that we don't accidentally use any normal C language built-in
++   type names in the first part of this file.  Instead we want to use *only*
++   the type names defined above.  The following macro definitions insure
++   that if we *do* accidentally use some normal C language built-in type name,
++   we will get a syntax error.  */
++
++#define char bogus_type
++#define short bogus_type
++#define int bogus_type
++#define long bogus_type
++#define unsigned bogus_type
++#define float bogus_type
++#define double bogus_type
++
++#if MIN_UNITS_PER_WORD > 4
++#define W_TYPE_SIZE (8 * BITS_PER_UNIT)
++#define Wtype DItype
++#define UWtype        UDItype
++#define HWtype        DItype
++#define UHWtype       UDItype
++#define DWtype        TItype
++#define UDWtype       UTItype
++#define __NW(a,b)     __ ## a ## di ## b
++#define __NDW(a,b)    __ ## a ## ti ## b
++#elif MIN_UNITS_PER_WORD > 2 \
++      || (MIN_UNITS_PER_WORD > 1 && LONG_LONG_TYPE_SIZE > 32)
++#define W_TYPE_SIZE (4 * BITS_PER_UNIT)
++#define Wtype SItype
++#define UWtype        USItype
++#define HWtype        SItype
++#define UHWtype       USItype
++#define DWtype        DItype
++#define UDWtype       UDItype
++#define __NW(a,b)     __ ## a ## si ## b
++#define __NDW(a,b)    __ ## a ## di ## b
++#elif MIN_UNITS_PER_WORD > 1
++#define W_TYPE_SIZE (2 * BITS_PER_UNIT)
++#define Wtype HItype
++#define UWtype        UHItype
++#define HWtype        HItype
++#define UHWtype       UHItype
++#define DWtype        SItype
++#define UDWtype       USItype
++#define __NW(a,b)     __ ## a ## hi ## b
++#define __NDW(a,b)    __ ## a ## si ## b
++#else
++#define W_TYPE_SIZE BITS_PER_UNIT
++#define Wtype QItype
++#define UWtype  UQItype
++#define HWtype        QItype
++#define UHWtype       UQItype
++#define DWtype        HItype
++#define UDWtype       UHItype
++#define __NW(a,b)     __ ## a ## qi ## b
++#define __NDW(a,b)    __ ## a ## hi ## b
++#endif
++
++#define Wtype_MAX ((Wtype)(((UWtype)1 << (W_TYPE_SIZE - 1)) - 1))
++#define Wtype_MIN (- Wtype_MAX - 1)
++
++#define __muldi3      __NDW(mul,3)
++#define __divdi3      __NDW(div,3)
++#define __udivdi3     __NDW(udiv,3)
++#define __moddi3      __NDW(mod,3)
++#define __umoddi3     __NDW(umod,3)
++#define __negdi2      __NDW(neg,2)
++#define __lshrdi3     __NDW(lshr,3)
++#define __ashldi3     __NDW(ashl,3)
++#define __ashrdi3     __NDW(ashr,3)
++#define __cmpdi2      __NDW(cmp,2)
++#define __ucmpdi2     __NDW(ucmp,2)
++#define __udivmoddi4  __NDW(udivmod,4)
++#define __fixunstfDI  __NDW(fixunstf,)
++#define __fixtfdi     __NDW(fixtf,)
++#define __fixunsxfDI  __NDW(fixunsxf,)
++#define __fixxfdi     __NDW(fixxf,)
++#define __fixunsdfDI  __NDW(fixunsdf,)
++#define __fixdfdi     __NDW(fixdf,)
++#define __fixunssfDI  __NDW(fixunssf,)
++#define __fixsfdi     __NDW(fixsf,)
++#define __floatdixf   __NDW(float,xf)
++#define __floatditf   __NDW(float,tf)
++#define __floatdidf   __NDW(float,df)
++#define __floatdisf   __NDW(float,sf)
++#define __fixunsxfSI  __NW(fixunsxf,)
++#define __fixunstfSI  __NW(fixunstf,)
++#define __fixunsdfSI  __NW(fixunsdf,)
++#define __fixunssfSI  __NW(fixunssf,)
++
++#define __ffsSI2      __NW(ffs,2)
++#define __clzSI2      __NW(clz,2)
++#define __ctzSI2      __NW(ctz,2)
++#define __popcountSI2 __NW(popcount,2)
++#define __paritySI2   __NW(parity,2)
++#define __ffsDI2      __NDW(ffs,2)
++#define __clzDI2      __NDW(clz,2)
++#define __ctzDI2      __NDW(ctz,2)
++#define __popcountDI2 __NDW(popcount,2)
++#define __parityDI2   __NDW(parity,2)
++
++extern DWtype __muldi3 (DWtype, DWtype);
++extern DWtype __divdi3 (DWtype, DWtype);
++extern UDWtype __udivdi3 (UDWtype, UDWtype);
++extern UDWtype __umoddi3 (UDWtype, UDWtype);
++extern DWtype __moddi3 (DWtype, DWtype);
++
++/* __udivmoddi4 is static inline when building other libgcc2 portions.  */
++#if (!defined (L_udivdi3) && !defined (L_divdi3) && \
++     !defined (L_umoddi3) && !defined (L_moddi3))
++extern UDWtype __udivmoddi4 (UDWtype, UDWtype, UDWtype *);
++#endif
++
++/* __negdi2 is static inline when building other libgcc2 portions.  */
++#if !defined(L_divdi3) && !defined(L_moddi3)
++extern DWtype __negdi2 (DWtype);
++#endif
++
++extern DWtype __lshrdi3 (DWtype, word_type);
++extern DWtype __ashldi3 (DWtype, word_type);
++extern DWtype __ashrdi3 (DWtype, word_type);
++
++/* __udiv_w_sdiv is static inline when building other libgcc2 portions.  */
++#if (!defined(L_udivdi3) && !defined(L_divdi3) && \
++     !defined(L_umoddi3) && !defined(L_moddi3))
++extern UWtype __udiv_w_sdiv (UWtype *, UWtype, UWtype, UWtype);
++#endif
++
++extern word_type __cmpdi2 (DWtype, DWtype);
++extern word_type __ucmpdi2 (DWtype, DWtype);
++
++extern Wtype __absvsi2 (Wtype);
++extern DWtype __absvdi2 (DWtype);
++extern Wtype __addvsi3 (Wtype, Wtype);
++extern DWtype __addvdi3 (DWtype, DWtype);
++extern Wtype __subvsi3 (Wtype, Wtype);
++extern DWtype __subvdi3 (DWtype, DWtype);
++extern Wtype __mulvsi3 (Wtype, Wtype);
++extern DWtype __mulvdi3 (DWtype, DWtype);
++extern Wtype __negvsi2 (Wtype);
++extern DWtype __negvdi2 (DWtype);
++
++#if BITS_PER_UNIT == 8
++extern DWtype __fixdfdi (DFtype);
++extern DWtype __fixsfdi (SFtype);
++extern DFtype __floatdidf (DWtype);
++extern SFtype __floatdisf (DWtype);
++extern UWtype __fixunsdfSI (DFtype);
++extern UWtype __fixunssfSI (SFtype);
++extern DWtype __fixunsdfDI (DFtype);
++extern DWtype __fixunssfDI (SFtype);
++
++#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
++extern DWtype __fixxfdi (XFtype);
++extern DWtype __fixunsxfDI (XFtype);
++extern XFtype __floatdixf (DWtype);
++extern UWtype __fixunsxfSI (XFtype);
++#endif
++
++#if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
++extern DWtype __fixunstfDI (TFtype);
++extern DWtype __fixtfdi (TFtype);
++extern TFtype __floatditf (DWtype);
++#endif
++#endif /* BITS_PER_UNIT == 8 */
++
++/* DWstructs are pairs of Wtype values in the order determined by
++   LIBGCC2_WORDS_BIG_ENDIAN.  */
++
++#if LIBGCC2_WORDS_BIG_ENDIAN
++  struct DWstruct {Wtype high, low;};
++#else
++  struct DWstruct {Wtype low, high;};
++#endif
++
++/* We need this union to unpack/pack DImode values, since we don't have
++   any arithmetic yet.  Incoming DImode parameters are stored into the
++   `ll' field, and the unpacked result is read from the struct `s'.  */
++
++typedef union
++{
++  struct DWstruct s;
++  DWtype ll;
++} DWunion;
++
++#include "longlong.h"
++
++#endif /* ! GCC_LIBGCC2_H */
+--- ./gcc/gcc/longlong.h
++++ ./gcc/gcc/longlong.h
+@@ -0,0 +1,1360 @@
++/* longlong.h -- definitions for mixed size 32/64 bit arithmetic.
++   Copyright (C) 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000
++   Free Software Foundation, Inc.
++
++   This definition file is free software; you can redistribute it
++   and/or modify it under the terms of the GNU General Public
++   License as published by the Free Software Foundation; either
++   version 2, or (at your option) any later version.
++
++   This definition file is distributed in the hope that it will be
++   useful, but WITHOUT ANY WARRANTY; without even the implied
++   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++   See the GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software
++   Foundation, Inc., 59 Temple Place - Suite 330,
++   Boston, MA 02111-1307, USA.  */
++
++/* You have to define the following before including this file:
++
++   UWtype -- An unsigned type, default type for operations (typically a "word")
++   UHWtype -- An unsigned type, at least half the size of UWtype.
++   UDWtype -- An unsigned type, at least twice as large a UWtype
++   W_TYPE_SIZE -- size in bits of UWtype
++
++   UQItype -- Unsigned 8 bit type.
++   SItype, USItype -- Signed and unsigned 32 bit types.
++   DItype, UDItype -- Signed and unsigned 64 bit types.
++
++   On a 32 bit machine UWtype should typically be USItype;
++   on a 64 bit machine, UWtype should typically be UDItype.
++*/
++
++#define __BITS4 (W_TYPE_SIZE / 4)
++#define __ll_B ((UWtype) 1 << (W_TYPE_SIZE / 2))
++#define __ll_lowpart(t) ((UWtype) (t) & (__ll_B - 1))
++#define __ll_highpart(t) ((UWtype) (t) >> (W_TYPE_SIZE / 2))
++
++#ifndef W_TYPE_SIZE
++#define W_TYPE_SIZE   32
++#define UWtype                USItype
++#define UHWtype               USItype
++#define UDWtype               UDItype
++#endif
++
++/* Define auxiliary asm macros.
++
++   1) umul_ppmm(high_prod, low_prod, multipler, multiplicand) multiplies two
++   UWtype integers MULTIPLER and MULTIPLICAND, and generates a two UWtype
++   word product in HIGH_PROD and LOW_PROD.
++
++   2) __umulsidi3(a,b) multiplies two UWtype integers A and B, and returns a
++   UDWtype product.  This is just a variant of umul_ppmm.
++
++   3) udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
++   denominator) divides a UDWtype, composed by the UWtype integers
++   HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and places the quotient
++   in QUOTIENT and the remainder in REMAINDER.  HIGH_NUMERATOR must be less
++   than DENOMINATOR for correct operation.  If, in addition, the most
++   significant bit of DENOMINATOR must be 1, then the pre-processor symbol
++   UDIV_NEEDS_NORMALIZATION is defined to 1.
++
++   4) sdiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
++   denominator).  Like udiv_qrnnd but the numbers are signed.  The quotient
++   is rounded towards 0.
++
++   5) count_leading_zeros(count, x) counts the number of zero-bits from the
++   msb to the first nonzero bit in the UWtype X.  This is the number of
++   steps X needs to be shifted left to set the msb.  Undefined for X == 0,
++   unless the symbol COUNT_LEADING_ZEROS_0 is defined to some value.
++
++   6) count_trailing_zeros(count, x) like count_leading_zeros, but counts
++   from the least significant end.
++
++   7) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,
++   high_addend_2, low_addend_2) adds two UWtype integers, composed by
++   HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and LOW_ADDEND_2
++   respectively.  The result is placed in HIGH_SUM and LOW_SUM.  Overflow
++   (i.e. carry out) is not stored anywhere, and is lost.
++
++   8) sub_ddmmss(high_difference, low_difference, high_minuend, low_minuend,
++   high_subtrahend, low_subtrahend) subtracts two two-word UWtype integers,
++   composed by HIGH_MINUEND_1 and LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and
++   LOW_SUBTRAHEND_2 respectively.  The result is placed in HIGH_DIFFERENCE
++   and LOW_DIFFERENCE.  Overflow (i.e. carry out) is not stored anywhere,
++   and is lost.
++
++   If any of these macros are left undefined for a particular CPU,
++   C macros are used.  */
++
++/* The CPUs come in alphabetical order below.
++
++   Please add support for more CPUs here, or improve the current support
++   for the CPUs below!
++   (E.g. WE32100, IBM360.)  */
++
++#if defined (__GNUC__) && !defined (NO_ASM)
++
++/* We sometimes need to clobber "cc" with gcc2, but that would not be
++   understood by gcc1.  Use cpp to avoid major code duplication.  */
++#if __GNUC__ < 2
++#define __CLOBBER_CC
++#define __AND_CLOBBER_CC
++#else /* __GNUC__ >= 2 */
++#define __CLOBBER_CC : "cc"
++#define __AND_CLOBBER_CC , "cc"
++#endif /* __GNUC__ < 2 */
++
++#if defined (__alpha) && W_TYPE_SIZE == 64
++#define umul_ppmm(ph, pl, m0, m1) \
++  do {                                                                        \
++    UDItype __m0 = (m0), __m1 = (m1);                                 \
++    (ph) = __builtin_alpha_umulh (__m0, __m1);                                \
++    (pl) = __m0 * __m1;                                                       \
++  } while (0)
++#define UMUL_TIME 46
++#ifndef LONGLONG_STANDALONE
++#define udiv_qrnnd(q, r, n1, n0, d) \
++  do { UDItype __r;                                                   \
++    (q) = __udiv_qrnnd (&__r, (n1), (n0), (d));                               \
++    (r) = __r;                                                                \
++  } while (0)
++extern UDItype __udiv_qrnnd (UDItype *, UDItype, UDItype, UDItype);
++#define UDIV_TIME 220
++#endif /* LONGLONG_STANDALONE */
++#ifdef __alpha_cix__
++#define count_leading_zeros(COUNT,X)  ((COUNT) = __builtin_clzl (X))
++#define count_trailing_zeros(COUNT,X) ((COUNT) = __builtin_ctzl (X))
++#define COUNT_LEADING_ZEROS_0 64
++#else
++extern const UQItype __clz_tab[] ATTRIBUTE_HIDDEN;
++#define count_leading_zeros(COUNT,X) \
++  do {                                                                        \
++    UDItype __xr = (X), __t, __a;                                     \
++    __t = __builtin_alpha_cmpbge (0, __xr);                           \
++    __a = __clz_tab[__t ^ 0xff] - 1;                                  \
++    __t = __builtin_alpha_extbl (__xr, __a);                          \
++    (COUNT) = 64 - (__clz_tab[__t] + __a*8);                          \
++  } while (0)
++#define count_trailing_zeros(COUNT,X) \
++  do {                                                                        \
++    UDItype __xr = (X), __t, __a;                                     \
++    __t = __builtin_alpha_cmpbge (0, __xr);                           \
++    __t = ~__t & -~__t;                                                       \
++    __a = ((__t & 0xCC) != 0) * 2;                                    \
++    __a += ((__t & 0xF0) != 0) * 4;                                   \
++    __a += ((__t & 0xAA) != 0);                                               \
++    __t = __builtin_alpha_extbl (__xr, __a);                          \
++    __a <<= 3;                                                                \
++    __t &= -__t;                                                      \
++    __a += ((__t & 0xCC) != 0) * 2;                                   \
++    __a += ((__t & 0xF0) != 0) * 4;                                   \
++    __a += ((__t & 0xAA) != 0);                                               \
++    (COUNT) = __a;                                                    \
++  } while (0)
++#endif /* __alpha_cix__ */
++#endif /* __alpha */
++
++#if defined (__arc__) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("add.f     %1, %4, %5\n\tadc       %0, %2, %3"             \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "%r" ((USItype) (ah)),                                     \
++           "rIJ" ((USItype) (bh)),                                    \
++           "%r" ((USItype) (al)),                                     \
++           "rIJ" ((USItype) (bl)))
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("sub.f     %1, %4, %5\n\tsbc       %0, %2, %3"             \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "r" ((USItype) (ah)),                                      \
++           "rIJ" ((USItype) (bh)),                                    \
++           "r" ((USItype) (al)),                                      \
++           "rIJ" ((USItype) (bl)))
++/* Call libgcc routine.  */
++#define umul_ppmm(w1, w0, u, v) \
++do {                                                                  \
++  DWunion __w;                                                                \
++  __w.ll = __umulsidi3 (u, v);                                                \
++  w1 = __w.s.high;                                                    \
++  w0 = __w.s.low;                                                     \
++} while (0)
++#define __umulsidi3 __umulsidi3
++UDItype __umulsidi3 (USItype, USItype);
++#endif
++
++#if defined (__arm__) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("adds      %1, %4, %5\n\tadc       %0, %2, %3"             \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "%r" ((USItype) (ah)),                                     \
++           "rI" ((USItype) (bh)),                                     \
++           "%r" ((USItype) (al)),                                     \
++           "rI" ((USItype) (bl)))
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("subs      %1, %4, %5\n\tsbc       %0, %2, %3"             \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "r" ((USItype) (ah)),                                      \
++           "rI" ((USItype) (bh)),                                     \
++           "r" ((USItype) (al)),                                      \
++           "rI" ((USItype) (bl)))
++#define umul_ppmm(xh, xl, a, b) \
++{register USItype __t0, __t1, __t2;                                   \
++  __asm__ ("%@ Inlined umul_ppmm\n"                                   \
++         "    mov     %2, %5, lsr #16\n"                              \
++         "    mov     %0, %6, lsr #16\n"                              \
++         "    bic     %3, %5, %2, lsl #16\n"                          \
++         "    bic     %4, %6, %0, lsl #16\n"                          \
++         "    mul     %1, %3, %4\n"                                   \
++         "    mul     %4, %2, %4\n"                                   \
++         "    mul     %3, %0, %3\n"                                   \
++         "    mul     %0, %2, %0\n"                                   \
++         "    adds    %3, %4, %3\n"                                   \
++         "    addcs   %0, %0, #65536\n"                               \
++         "    adds    %1, %1, %3, lsl #16\n"                          \
++         "    adc     %0, %0, %3, lsr #16"                            \
++         : "=&r" ((USItype) (xh)),                                    \
++           "=r" ((USItype) (xl)),                                     \
++           "=&r" (__t0), "=&r" (__t1), "=r" (__t2)                    \
++         : "r" ((USItype) (a)),                                       \
++           "r" ((USItype) (b)));}
++#define UMUL_TIME 20
++#define UDIV_TIME 100
++#endif /* __arm__ */
++
++#if defined (__hppa) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("add %4,%5,%1\n\taddc %2,%3,%0"                            \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "%rM" ((USItype) (ah)),                                    \
++           "rM" ((USItype) (bh)),                                     \
++           "%rM" ((USItype) (al)),                                    \
++           "rM" ((USItype) (bl)))
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("sub %4,%5,%1\n\tsubb %2,%3,%0"                            \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "rM" ((USItype) (ah)),                                     \
++           "rM" ((USItype) (bh)),                                     \
++           "rM" ((USItype) (al)),                                     \
++           "rM" ((USItype) (bl)))
++#if defined (_PA_RISC1_1)
++#define umul_ppmm(w1, w0, u, v) \
++  do {                                                                        \
++    union                                                             \
++      {                                                                       \
++      UDItype __f;                                                    \
++      struct {USItype __w1, __w0;} __w1w0;                            \
++      } __t;                                                          \
++    __asm__ ("xmpyu %1,%2,%0"                                         \
++           : "=x" (__t.__f)                                           \
++           : "x" ((USItype) (u)),                                     \
++             "x" ((USItype) (v)));                                    \
++    (w1) = __t.__w1w0.__w1;                                           \
++    (w0) = __t.__w1w0.__w0;                                           \
++     } while (0)
++#define UMUL_TIME 8
++#else
++#define UMUL_TIME 30
++#endif
++#define UDIV_TIME 40
++#define count_leading_zeros(count, x) \
++  do {                                                                        \
++    USItype __tmp;                                                    \
++    __asm__ (                                                         \
++       "ldi           1,%0\n"                                         \
++"     extru,=         %1,15,16,%%r0           ; Bits 31..16 zero?\n"  \
++"     extru,tr        %1,15,16,%1             ; No.  Shift down, skip add.\n"\
++"     ldo             16(%0),%0               ; Yes.  Perform add.\n" \
++"     extru,=         %1,23,8,%%r0            ; Bits 15..8 zero?\n"   \
++"     extru,tr        %1,23,8,%1              ; No.  Shift down, skip add.\n"\
++"     ldo             8(%0),%0                ; Yes.  Perform add.\n" \
++"     extru,=         %1,27,4,%%r0            ; Bits 7..4 zero?\n"    \
++"     extru,tr        %1,27,4,%1              ; No.  Shift down, skip add.\n"\
++"     ldo             4(%0),%0                ; Yes.  Perform add.\n" \
++"     extru,=         %1,29,2,%%r0            ; Bits 3..2 zero?\n"    \
++"     extru,tr        %1,29,2,%1              ; No.  Shift down, skip add.\n"\
++"     ldo             2(%0),%0                ; Yes.  Perform add.\n" \
++"     extru           %1,30,1,%1              ; Extract bit 1.\n"     \
++"     sub             %0,%1,%0                ; Subtract it.\n"       \
++      : "=r" (count), "=r" (__tmp) : "1" (x));                        \
++  } while (0)
++#endif
++
++#if (defined (__i370__) || defined (__s390__) || defined (__mvs__)) && W_TYPE_SIZE == 32
++#define smul_ppmm(xh, xl, m0, m1) \
++  do {                                                                        \
++    union {DItype __ll;                                                       \
++         struct {USItype __h, __l;} __i;                              \
++        } __x;                                                        \
++    __asm__ ("lr %N0,%1\n\tmr %0,%2"                                  \
++           : "=&r" (__x.__ll)                                         \
++           : "r" (m0), "r" (m1));                                     \
++    (xh) = __x.__i.__h; (xl) = __x.__i.__l;                           \
++  } while (0)
++#define sdiv_qrnnd(q, r, n1, n0, d) \
++  do {                                                                        \
++    union {DItype __ll;                                                       \
++         struct {USItype __h, __l;} __i;                              \
++        } __x;                                                        \
++    __x.__i.__h = n1; __x.__i.__l = n0;                                       \
++    __asm__ ("dr %0,%2"                                                       \
++           : "=r" (__x.__ll)                                          \
++           : "0" (__x.__ll), "r" (d));                                \
++    (q) = __x.__i.__l; (r) = __x.__i.__h;                             \
++  } while (0)
++#endif
++
++#if (defined (__i386__) || defined (__i486__)) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("addl %5,%1\n\tadcl %3,%0"                                 \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "%0" ((USItype) (ah)),                                     \
++           "g" ((USItype) (bh)),                                      \
++           "%1" ((USItype) (al)),                                     \
++           "g" ((USItype) (bl)))
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("subl %5,%1\n\tsbbl %3,%0"                                 \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "0" ((USItype) (ah)),                                      \
++           "g" ((USItype) (bh)),                                      \
++           "1" ((USItype) (al)),                                      \
++           "g" ((USItype) (bl)))
++#define umul_ppmm(w1, w0, u, v) \
++  __asm__ ("mull %3"                                                  \
++         : "=a" ((USItype) (w0)),                                     \
++           "=d" ((USItype) (w1))                                      \
++         : "%0" ((USItype) (u)),                                      \
++           "rm" ((USItype) (v)))
++#define udiv_qrnnd(q, r, n1, n0, dv) \
++  __asm__ ("divl %4"                                                  \
++         : "=a" ((USItype) (q)),                                      \
++           "=d" ((USItype) (r))                                       \
++         : "0" ((USItype) (n0)),                                      \
++           "1" ((USItype) (n1)),                                      \
++           "rm" ((USItype) (dv)))
++#define count_leading_zeros(count, x) \
++  do {                                                                        \
++    USItype __cbtmp;                                                  \
++    __asm__ ("bsrl %1,%0"                                             \
++           : "=r" (__cbtmp) : "rm" ((USItype) (x)));                  \
++    (count) = __cbtmp ^ 31;                                           \
++  } while (0)
++#define count_trailing_zeros(count, x) \
++  __asm__ ("bsfl %1,%0" : "=r" (count) : "rm" ((USItype)(x)))
++#define UMUL_TIME 40
++#define UDIV_TIME 40
++#endif /* 80x86 */
++
++#if defined (__i960__) && W_TYPE_SIZE == 32
++#define umul_ppmm(w1, w0, u, v) \
++  ({union {UDItype __ll;                                              \
++         struct {USItype __l, __h;} __i;                              \
++        } __xx;                                                       \
++  __asm__ ("emul      %2,%1,%0"                                       \
++         : "=d" (__xx.__ll)                                           \
++         : "%dI" ((USItype) (u)),                                     \
++           "dI" ((USItype) (v)));                                     \
++  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
++#define __umulsidi3(u, v) \
++  ({UDItype __w;                                                      \
++    __asm__ ("emul    %2,%1,%0"                                       \
++           : "=d" (__w)                                               \
++           : "%dI" ((USItype) (u)),                                   \
++             "dI" ((USItype) (v)));                                   \
++    __w; })
++#endif /* __i960__ */
++
++#if defined (__M32R__) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  /* The cmp clears the condition bit.  */ \
++  __asm__ ("cmp %0,%0\n\taddx %1,%5\n\taddx %0,%3"                    \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "0" ((USItype) (ah)),                                      \
++           "r" ((USItype) (bh)),                                      \
++           "1" ((USItype) (al)),                                      \
++           "r" ((USItype) (bl))                                       \
++         : "cbit")
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  /* The cmp clears the condition bit.  */ \
++  __asm__ ("cmp %0,%0\n\tsubx %1,%5\n\tsubx %0,%3"                    \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "0" ((USItype) (ah)),                                      \
++           "r" ((USItype) (bh)),                                      \
++           "1" ((USItype) (al)),                                      \
++           "r" ((USItype) (bl))                                       \
++         : "cbit")
++#endif /* __M32R__ */
++
++#if defined (__mc68000__) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("add%.l %5,%1\n\taddx%.l %3,%0"                            \
++         : "=d" ((USItype) (sh)),                                     \
++           "=&d" ((USItype) (sl))                                     \
++         : "%0" ((USItype) (ah)),                                     \
++           "d" ((USItype) (bh)),                                      \
++           "%1" ((USItype) (al)),                                     \
++           "g" ((USItype) (bl)))
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("sub%.l %5,%1\n\tsubx%.l %3,%0"                            \
++         : "=d" ((USItype) (sh)),                                     \
++           "=&d" ((USItype) (sl))                                     \
++         : "0" ((USItype) (ah)),                                      \
++           "d" ((USItype) (bh)),                                      \
++           "1" ((USItype) (al)),                                      \
++           "g" ((USItype) (bl)))
++
++/* The '020, '030, '040 and CPU32 have 32x32->64 and 64/32->32q-32r.  */
++#if defined (__mc68020__) || defined(mc68020) \
++      || defined(__mc68030__) || defined(mc68030) \
++      || defined(__mc68040__) || defined(mc68040) \
++      || defined(__mcpu32__) || defined(mcpu32)
++#define umul_ppmm(w1, w0, u, v) \
++  __asm__ ("mulu%.l %3,%1:%0"                                         \
++         : "=d" ((USItype) (w0)),                                     \
++           "=d" ((USItype) (w1))                                      \
++         : "%0" ((USItype) (u)),                                      \
++           "dmi" ((USItype) (v)))
++#define UMUL_TIME 45
++#define udiv_qrnnd(q, r, n1, n0, d) \
++  __asm__ ("divu%.l %4,%1:%0"                                         \
++         : "=d" ((USItype) (q)),                                      \
++           "=d" ((USItype) (r))                                       \
++         : "0" ((USItype) (n0)),                                      \
++           "1" ((USItype) (n1)),                                      \
++           "dmi" ((USItype) (d)))
++#define UDIV_TIME 90
++#define sdiv_qrnnd(q, r, n1, n0, d) \
++  __asm__ ("divs%.l %4,%1:%0"                                         \
++         : "=d" ((USItype) (q)),                                      \
++           "=d" ((USItype) (r))                                       \
++         : "0" ((USItype) (n0)),                                      \
++           "1" ((USItype) (n1)),                                      \
++           "dmi" ((USItype) (d)))
++
++#else /* not mc68020 */
++#if defined(__mcoldfire__)
++#define umul_ppmm(xh, xl, a, b) \
++  __asm__ ("| Inlined umul_ppmm\n"                                    \
++         "    move%.l %2,%/d0\n"                                      \
++         "    move%.l %3,%/d1\n"                                      \
++         "    move%.l %/d0,%/d2\n"                                    \
++         "    swap    %/d0\n"                                         \
++         "    move%.l %/d1,%/d3\n"                                    \
++         "    swap    %/d1\n"                                         \
++         "    move%.w %/d2,%/d4\n"                                    \
++         "    mulu    %/d3,%/d4\n"                                    \
++         "    mulu    %/d1,%/d2\n"                                    \
++         "    mulu    %/d0,%/d3\n"                                    \
++         "    mulu    %/d0,%/d1\n"                                    \
++         "    move%.l %/d4,%/d0\n"                                    \
++         "    clr%.w  %/d0\n"                                         \
++         "    swap    %/d0\n"                                         \
++         "    add%.l  %/d0,%/d2\n"                                    \
++         "    add%.l  %/d3,%/d2\n"                                    \
++         "    jcc     1f\n"                                           \
++         "    add%.l  %#65536,%/d1\n"                                 \
++         "1:  swap    %/d2\n"                                         \
++         "    moveq   %#0,%/d0\n"                                     \
++         "    move%.w %/d2,%/d0\n"                                    \
++         "    move%.w %/d4,%/d2\n"                                    \
++         "    move%.l %/d2,%1\n"                                      \
++         "    add%.l  %/d1,%/d0\n"                                    \
++         "    move%.l %/d0,%0"                                        \
++         : "=g" ((USItype) (xh)),                                     \
++           "=g" ((USItype) (xl))                                      \
++         : "g" ((USItype) (a)),                                       \
++           "g" ((USItype) (b))                                        \
++         : "d0", "d1", "d2", "d3", "d4")
++#define UMUL_TIME 100
++#define UDIV_TIME 400
++#else /* not ColdFire */
++/* %/ inserts REGISTER_PREFIX, %# inserts IMMEDIATE_PREFIX.  */
++#define umul_ppmm(xh, xl, a, b) \
++  __asm__ ("| Inlined umul_ppmm\n"                                    \
++         "    move%.l %2,%/d0\n"                                      \
++         "    move%.l %3,%/d1\n"                                      \
++         "    move%.l %/d0,%/d2\n"                                    \
++         "    swap    %/d0\n"                                         \
++         "    move%.l %/d1,%/d3\n"                                    \
++         "    swap    %/d1\n"                                         \
++         "    move%.w %/d2,%/d4\n"                                    \
++         "    mulu    %/d3,%/d4\n"                                    \
++         "    mulu    %/d1,%/d2\n"                                    \
++         "    mulu    %/d0,%/d3\n"                                    \
++         "    mulu    %/d0,%/d1\n"                                    \
++         "    move%.l %/d4,%/d0\n"                                    \
++         "    eor%.w  %/d0,%/d0\n"                                    \
++         "    swap    %/d0\n"                                         \
++         "    add%.l  %/d0,%/d2\n"                                    \
++         "    add%.l  %/d3,%/d2\n"                                    \
++         "    jcc     1f\n"                                           \
++         "    add%.l  %#65536,%/d1\n"                                 \
++         "1:  swap    %/d2\n"                                         \
++         "    moveq   %#0,%/d0\n"                                     \
++         "    move%.w %/d2,%/d0\n"                                    \
++         "    move%.w %/d4,%/d2\n"                                    \
++         "    move%.l %/d2,%1\n"                                      \
++         "    add%.l  %/d1,%/d0\n"                                    \
++         "    move%.l %/d0,%0"                                        \
++         : "=g" ((USItype) (xh)),                                     \
++           "=g" ((USItype) (xl))                                      \
++         : "g" ((USItype) (a)),                                       \
++           "g" ((USItype) (b))                                        \
++         : "d0", "d1", "d2", "d3", "d4")
++#define UMUL_TIME 100
++#define UDIV_TIME 400
++#endif /* not ColdFire */
++#endif /* not mc68020 */
++
++/* The '020, '030, '040 and '060 have bitfield insns.
++   cpu32 disguises as a 68020, but lacks them.  */
++#if ( defined (__mc68020__) || defined(mc68020) \
++              || defined(__mc68030__) || defined(mc68030) \
++              || defined(__mc68040__) || defined(mc68040) \
++              || defined(__mc68060__) || defined(mc68060) ) \
++      && !defined(__mcpu32__)
++#define count_leading_zeros(count, x) \
++  __asm__ ("bfffo %1{%b2:%b2},%0"                                     \
++         : "=d" ((USItype) (count))                                   \
++         : "od" ((USItype) (x)), "n" (0))
++#endif
++#endif /* mc68000 */
++
++#if defined (__m88000__) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("addu.co %1,%r4,%r5\n\taddu.ci %0,%r2,%r3"                 \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "%rJ" ((USItype) (ah)),                                    \
++           "rJ" ((USItype) (bh)),                                     \
++           "%rJ" ((USItype) (al)),                                    \
++           "rJ" ((USItype) (bl)))
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("subu.co %1,%r4,%r5\n\tsubu.ci %0,%r2,%r3"                 \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "rJ" ((USItype) (ah)),                                     \
++           "rJ" ((USItype) (bh)),                                     \
++           "rJ" ((USItype) (al)),                                     \
++           "rJ" ((USItype) (bl)))
++#define count_leading_zeros(count, x) \
++  do {                                                                        \
++    USItype __cbtmp;                                                  \
++    __asm__ ("ff1 %0,%1"                                              \
++           : "=r" (__cbtmp)                                           \
++           : "r" ((USItype) (x)));                                    \
++    (count) = __cbtmp ^ 31;                                           \
++  } while (0)
++#define COUNT_LEADING_ZEROS_0 63 /* sic */
++#if defined (__mc88110__)
++#define umul_ppmm(wh, wl, u, v) \
++  do {                                                                        \
++    union {UDItype __ll;                                              \
++         struct {USItype __h, __l;} __i;                              \
++        } __xx;                                                       \
++    __asm__ ("mulu.d  %0,%1,%2"                                       \
++           : "=r" (__xx.__ll)                                         \
++           : "r" ((USItype) (u)),                                     \
++             "r" ((USItype) (v)));                                    \
++    (wh) = __xx.__i.__h;                                              \
++    (wl) = __xx.__i.__l;                                              \
++  } while (0)
++#define udiv_qrnnd(q, r, n1, n0, d) \
++  ({union {UDItype __ll;                                              \
++         struct {USItype __h, __l;} __i;                              \
++        } __xx;                                                       \
++  USItype __q;                                                                \
++  __xx.__i.__h = (n1); __xx.__i.__l = (n0);                           \
++  __asm__ ("divu.d %0,%1,%2"                                          \
++         : "=r" (__q)                                                 \
++         : "r" (__xx.__ll),                                           \
++           "r" ((USItype) (d)));                                      \
++  (r) = (n0) - __q * (d); (q) = __q; })
++#define UMUL_TIME 5
++#define UDIV_TIME 25
++#else
++#define UMUL_TIME 17
++#define UDIV_TIME 150
++#endif /* __mc88110__ */
++#endif /* __m88000__ */
++
++#if defined (__mips__) && W_TYPE_SIZE == 32
++#define umul_ppmm(w1, w0, u, v) \
++  __asm__ ("multu %2,%3"                                              \
++         : "=l" ((USItype) (w0)),                                     \
++           "=h" ((USItype) (w1))                                      \
++         : "d" ((USItype) (u)),                                       \
++           "d" ((USItype) (v)))
++#define UMUL_TIME 10
++#define UDIV_TIME 100
++#endif /* __mips__ */
++
++#if defined (__ns32000__) && W_TYPE_SIZE == 32
++#define umul_ppmm(w1, w0, u, v) \
++  ({union {UDItype __ll;                                              \
++         struct {USItype __l, __h;} __i;                              \
++        } __xx;                                                       \
++  __asm__ ("meid %2,%0"                                                       \
++         : "=g" (__xx.__ll)                                           \
++         : "%0" ((USItype) (u)),                                      \
++           "g" ((USItype) (v)));                                      \
++  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
++#define __umulsidi3(u, v) \
++  ({UDItype __w;                                                      \
++    __asm__ ("meid %2,%0"                                             \
++           : "=g" (__w)                                               \
++           : "%0" ((USItype) (u)),                                    \
++             "g" ((USItype) (v)));                                    \
++    __w; })
++#define udiv_qrnnd(q, r, n1, n0, d) \
++  ({union {UDItype __ll;                                              \
++         struct {USItype __l, __h;} __i;                              \
++        } __xx;                                                       \
++  __xx.__i.__h = (n1); __xx.__i.__l = (n0);                           \
++  __asm__ ("deid %2,%0"                                                       \
++         : "=g" (__xx.__ll)                                           \
++         : "0" (__xx.__ll),                                           \
++           "g" ((USItype) (d)));                                      \
++  (r) = __xx.__i.__l; (q) = __xx.__i.__h; })
++#define count_trailing_zeros(count,x) \
++  do {                                                                        \
++    __asm__ ("ffsd     %2,%0"                                         \
++            : "=r" ((USItype) (count))                                        \
++            : "0" ((USItype) 0),                                      \
++              "r" ((USItype) (x)));                                   \
++  } while (0)
++#endif /* __ns32000__ */
++
++/* FIXME: We should test _IBMR2 here when we add assembly support for the
++   system vendor compilers.
++   FIXME: What's needed for gcc PowerPC VxWorks?  __vxworks__ is not good
++   enough, since that hits ARM and m68k too.  */
++#if (defined (_ARCH_PPC)      /* AIX */                               \
++     || defined (_ARCH_PWR)   /* AIX */                               \
++     || defined (_ARCH_COM)   /* AIX */                               \
++     || defined (__powerpc__) /* gcc */                               \
++     || defined (__POWERPC__) /* BEOS */                              \
++     || defined (__ppc__)     /* Darwin */                            \
++     || defined (PPC)         /* GNU/Linux, SysV */                   \
++     ) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  do {                                                                        \
++    if (__builtin_constant_p (bh) && (bh) == 0)                               \
++      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2"         \
++           : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
++    else if (__builtin_constant_p (bh) && (bh) == ~(USItype) 0)               \
++      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2"         \
++           : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
++    else                                                              \
++      __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3"                \
++           : "=r" (sh), "=&r" (sl)                                    \
++           : "%r" (ah), "r" (bh), "%r" (al), "rI" (bl));              \
++  } while (0)
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  do {                                                                        \
++    if (__builtin_constant_p (ah) && (ah) == 0)                               \
++      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2"     \
++             : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
++    else if (__builtin_constant_p (ah) && (ah) == ~(USItype) 0)               \
++      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2"     \
++             : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
++    else if (__builtin_constant_p (bh) && (bh) == 0)                  \
++      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2"               \
++             : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
++    else if (__builtin_constant_p (bh) && (bh) == ~(USItype) 0)               \
++      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2"               \
++             : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
++    else                                                              \
++      __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2"    \
++             : "=r" (sh), "=&r" (sl)                                  \
++             : "r" (ah), "r" (bh), "rI" (al), "r" (bl));              \
++  } while (0)
++#define count_leading_zeros(count, x) \
++  __asm__ ("{cntlz|cntlzw} %0,%1" : "=r" (count) : "r" (x))
++#define COUNT_LEADING_ZEROS_0 32
++#if defined (_ARCH_PPC) || defined (__powerpc__) || defined (__POWERPC__) \
++  || defined (__ppc__) || defined (PPC)
++#define umul_ppmm(ph, pl, m0, m1) \
++  do {                                                                        \
++    USItype __m0 = (m0), __m1 = (m1);                                 \
++    __asm__ ("mulhwu %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1));    \
++    (pl) = __m0 * __m1;                                                       \
++  } while (0)
++#define UMUL_TIME 15
++#define smul_ppmm(ph, pl, m0, m1) \
++  do {                                                                        \
++    SItype __m0 = (m0), __m1 = (m1);                                  \
++    __asm__ ("mulhw %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1));     \
++    (pl) = __m0 * __m1;                                                       \
++  } while (0)
++#define SMUL_TIME 14
++#define UDIV_TIME 120
++#elif defined (_ARCH_PWR)
++#define UMUL_TIME 8
++#define smul_ppmm(xh, xl, m0, m1) \
++  __asm__ ("mul %0,%2,%3" : "=r" (xh), "=q" (xl) : "r" (m0), "r" (m1))
++#define SMUL_TIME 4
++#define sdiv_qrnnd(q, r, nh, nl, d) \
++  __asm__ ("div %0,%2,%4" : "=r" (q), "=q" (r) : "r" (nh), "1" (nl), "r" (d))
++#define UDIV_TIME 100
++#endif
++#endif /* 32-bit POWER architecture variants.  */
++
++/* We should test _IBMR2 here when we add assembly support for the system
++   vendor compilers.  */
++#if (defined (_ARCH_PPC64) || defined (__powerpc64__)) && W_TYPE_SIZE == 64
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  do {                                                                        \
++    if (__builtin_constant_p (bh) && (bh) == 0)                               \
++      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2"         \
++           : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
++    else if (__builtin_constant_p (bh) && (bh) == ~(UDItype) 0)               \
++      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2"         \
++           : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
++    else                                                              \
++      __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3"                \
++           : "=r" (sh), "=&r" (sl)                                    \
++           : "%r" (ah), "r" (bh), "%r" (al), "rI" (bl));              \
++  } while (0)
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  do {                                                                        \
++    if (__builtin_constant_p (ah) && (ah) == 0)                               \
++      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2"     \
++             : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
++    else if (__builtin_constant_p (ah) && (ah) == ~(UDItype) 0)               \
++      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2"     \
++             : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
++    else if (__builtin_constant_p (bh) && (bh) == 0)                  \
++      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2"               \
++             : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
++    else if (__builtin_constant_p (bh) && (bh) == ~(UDItype) 0)               \
++      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2"               \
++             : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
++    else                                                              \
++      __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2"    \
++             : "=r" (sh), "=&r" (sl)                                  \
++             : "r" (ah), "r" (bh), "rI" (al), "r" (bl));              \
++  } while (0)
++#define count_leading_zeros(count, x) \
++  __asm__ ("cntlzd %0,%1" : "=r" (count) : "r" (x))
++#define COUNT_LEADING_ZEROS_0 64
++#define umul_ppmm(ph, pl, m0, m1) \
++  do {                                                                        \
++    UDItype __m0 = (m0), __m1 = (m1);                                 \
++    __asm__ ("mulhdu %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1));    \
++    (pl) = __m0 * __m1;                                                       \
++  } while (0)
++#define UMUL_TIME 15
++#define smul_ppmm(ph, pl, m0, m1) \
++  do {                                                                        \
++    DItype __m0 = (m0), __m1 = (m1);                                  \
++    __asm__ ("mulhd %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1));     \
++    (pl) = __m0 * __m1;                                                       \
++  } while (0)
++#define SMUL_TIME 14  /* ??? */
++#define UDIV_TIME 120 /* ??? */
++#endif /* 64-bit PowerPC.  */
++
++#if defined (__ibm032__) /* RT/ROMP */ && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("a %1,%5\n\tae %0,%3"                                      \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "%0" ((USItype) (ah)),                                     \
++           "r" ((USItype) (bh)),                                      \
++           "%1" ((USItype) (al)),                                     \
++           "r" ((USItype) (bl)))
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("s %1,%5\n\tse %0,%3"                                      \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "0" ((USItype) (ah)),                                      \
++           "r" ((USItype) (bh)),                                      \
++           "1" ((USItype) (al)),                                      \
++           "r" ((USItype) (bl)))
++#define umul_ppmm(ph, pl, m0, m1) \
++  do {                                                                        \
++    USItype __m0 = (m0), __m1 = (m1);                                 \
++    __asm__ (                                                         \
++       "s     r2,r2\n"                                                \
++"     mts     r10,%2\n"                                               \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     m       r2,%3\n"                                                \
++"     cas     %0,r2,r0\n"                                             \
++"     mfs     r10,%1"                                                 \
++           : "=r" ((USItype) (ph)),                                   \
++             "=r" ((USItype) (pl))                                    \
++           : "%r" (__m0),                                             \
++              "r" (__m1)                                              \
++           : "r2");                                                   \
++    (ph) += ((((SItype) __m0 >> 31) & __m1)                           \
++           + (((SItype) __m1 >> 31) & __m0));                         \
++  } while (0)
++#define UMUL_TIME 20
++#define UDIV_TIME 200
++#define count_leading_zeros(count, x) \
++  do {                                                                        \
++    if ((x) >= 0x10000)                                                       \
++      __asm__ ("clz   %0,%1"                                          \
++             : "=r" ((USItype) (count))                               \
++             : "r" ((USItype) (x) >> 16));                            \
++    else                                                              \
++      {                                                                       \
++      __asm__ ("clz   %0,%1"                                          \
++               : "=r" ((USItype) (count))                             \
++               : "r" ((USItype) (x)));                                        \
++      (count) += 16;                                                  \
++      }                                                                       \
++  } while (0)
++#endif
++
++#if defined (__sh2__) && W_TYPE_SIZE == 32
++#define umul_ppmm(w1, w0, u, v) \
++  __asm__ (                                                           \
++       "dmulu.l       %2,%3\n\tsts    macl,%1\n\tsts  mach,%0"                \
++         : "=r" ((USItype)(w1)),                                      \
++           "=r" ((USItype)(w0))                                       \
++         : "r" ((USItype)(u)),                                        \
++           "r" ((USItype)(v))                                         \
++         : "macl", "mach")
++#define UMUL_TIME 5
++#endif
++
++#if defined (__SH5__) && __SHMEDIA__ && W_TYPE_SIZE == 32
++#define __umulsidi3(u,v) ((UDItype)(USItype)u*(USItype)v)
++#define count_leading_zeros(count, x) \
++  do                                                                  \
++    {                                                                 \
++      UDItype x_ = (USItype)(x);                                      \
++      SItype c_;                                                      \
++                                                                      \
++      __asm__ ("nsb %1, %0" : "=r" (c_) : "r" (x_));                  \
++      (count) = c_ - 31;                                              \
++    }                                                                 \
++  while (0)
++#define COUNT_LEADING_ZEROS_0 32
++#endif
++
++#if defined (__sparc__) && !defined (__arch64__) && !defined (__sparcv9) \
++    && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("addcc %r4,%5,%1\n\taddx %r2,%3,%0"                                \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "%rJ" ((USItype) (ah)),                                    \
++           "rI" ((USItype) (bh)),                                     \
++           "%rJ" ((USItype) (al)),                                    \
++           "rI" ((USItype) (bl))                                      \
++         __CLOBBER_CC)
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("subcc %r4,%5,%1\n\tsubx %r2,%3,%0"                                \
++         : "=r" ((USItype) (sh)),                                     \
++           "=&r" ((USItype) (sl))                                     \
++         : "rJ" ((USItype) (ah)),                                     \
++           "rI" ((USItype) (bh)),                                     \
++           "rJ" ((USItype) (al)),                                     \
++           "rI" ((USItype) (bl))                                      \
++         __CLOBBER_CC)
++#if defined (__sparc_v8__)
++#define umul_ppmm(w1, w0, u, v) \
++  __asm__ ("umul %2,%3,%1;rd %%y,%0"                                  \
++         : "=r" ((USItype) (w1)),                                     \
++           "=r" ((USItype) (w0))                                      \
++         : "r" ((USItype) (u)),                                       \
++           "r" ((USItype) (v)))
++#define udiv_qrnnd(__q, __r, __n1, __n0, __d) \
++  __asm__ ("mov %2,%%y;nop;nop;nop;udiv %3,%4,%0;umul %0,%4,%1;sub %3,%1,%1"\
++         : "=&r" ((USItype) (__q)),                                   \
++           "=&r" ((USItype) (__r))                                    \
++         : "r" ((USItype) (__n1)),                                    \
++           "r" ((USItype) (__n0)),                                    \
++           "r" ((USItype) (__d)))
++#else
++#if defined (__sparclite__)
++/* This has hardware multiply but not divide.  It also has two additional
++   instructions scan (ffs from high bit) and divscc.  */
++#define umul_ppmm(w1, w0, u, v) \
++  __asm__ ("umul %2,%3,%1;rd %%y,%0"                                  \
++         : "=r" ((USItype) (w1)),                                     \
++           "=r" ((USItype) (w0))                                      \
++         : "r" ((USItype) (u)),                                       \
++           "r" ((USItype) (v)))
++#define udiv_qrnnd(q, r, n1, n0, d) \
++  __asm__ ("! Inlined udiv_qrnnd\n"                                   \
++"     wr      %%g0,%2,%%y     ! Not a delayed write for sparclite\n"  \
++"     tst     %%g0\n"                                                 \
++"     divscc  %3,%4,%%g1\n"                                           \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%%g1\n"                                         \
++"     divscc  %%g1,%4,%0\n"                                           \
++"     rd      %%y,%1\n"                                               \
++"     bl,a 1f\n"                                                      \
++"     add     %1,%4,%1\n"                                             \
++"1:   ! End of inline udiv_qrnnd"                                     \
++         : "=r" ((USItype) (q)),                                      \
++           "=r" ((USItype) (r))                                       \
++         : "r" ((USItype) (n1)),                                      \
++           "r" ((USItype) (n0)),                                      \
++           "rI" ((USItype) (d))                                       \
++         : "g1" __AND_CLOBBER_CC)
++#define UDIV_TIME 37
++#define count_leading_zeros(count, x) \
++  do {                                                                  \
++  __asm__ ("scan %1,1,%0"                                               \
++           : "=r" ((USItype) (count))                                   \
++           : "r" ((USItype) (x)));                                    \
++  } while (0)
++/* Early sparclites return 63 for an argument of 0, but they warn that future
++   implementations might change this.  Therefore, leave COUNT_LEADING_ZEROS_0
++   undefined.  */
++#else
++/* SPARC without integer multiplication and divide instructions.
++   (i.e. at least Sun4/20,40,60,65,75,110,260,280,330,360,380,470,490) */
++#define umul_ppmm(w1, w0, u, v) \
++  __asm__ ("! Inlined umul_ppmm\n"                                    \
++"     wr      %%g0,%2,%%y     ! SPARC has 0-3 delay insn after a wr\n"\
++"     sra     %3,31,%%o5      ! Don't move this insn\n"               \
++"     and     %2,%%o5,%%o5    ! Don't move this insn\n"               \
++"     andcc   %%g0,0,%%g1     ! Don't move this insn\n"               \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,%3,%%g1\n"                                         \
++"     mulscc  %%g1,0,%%g1\n"                                          \
++"     add     %%g1,%%o5,%0\n"                                         \
++"     rd      %%y,%1"                                                 \
++         : "=r" ((USItype) (w1)),                                     \
++           "=r" ((USItype) (w0))                                      \
++         : "%rI" ((USItype) (u)),                                     \
++           "r" ((USItype) (v))                                                \
++         : "g1", "o5" __AND_CLOBBER_CC)
++#define UMUL_TIME 39          /* 39 instructions */
++/* It's quite necessary to add this much assembler for the sparc.
++   The default udiv_qrnnd (in C) is more than 10 times slower!  */
++#define udiv_qrnnd(__q, __r, __n1, __n0, __d) \
++  __asm__ ("! Inlined udiv_qrnnd\n"                                   \
++"     mov     32,%%g1\n"                                              \
++"     subcc   %1,%2,%%g0\n"                                           \
++"1:   bcs     5f\n"                                                   \
++"      addxcc %0,%0,%0        ! shift n1n0 and a q-bit in lsb\n"      \
++"     sub     %1,%2,%1        ! this kills msb of n\n"                \
++"     addx    %1,%1,%1        ! so this can't give carry\n"           \
++"     subcc   %%g1,1,%%g1\n"                                          \
++"2:   bne     1b\n"                                                   \
++"      subcc  %1,%2,%%g0\n"                                           \
++"     bcs     3f\n"                                                   \
++"      addxcc %0,%0,%0        ! shift n1n0 and a q-bit in lsb\n"      \
++"     b       3f\n"                                                   \
++"      sub    %1,%2,%1        ! this kills msb of n\n"                \
++"4:   sub     %1,%2,%1\n"                                             \
++"5:   addxcc  %1,%1,%1\n"                                             \
++"     bcc     2b\n"                                                   \
++"      subcc  %%g1,1,%%g1\n"                                          \
++"! Got carry from n.  Subtract next step to cancel this carry.\n"     \
++"     bne     4b\n"                                                   \
++"      addcc  %0,%0,%0        ! shift n1n0 and a 0-bit in lsb\n"      \
++"     sub     %1,%2,%1\n"                                             \
++"3:   xnor    %0,0,%0\n"                                              \
++"     ! End of inline udiv_qrnnd"                                     \
++         : "=&r" ((USItype) (__q)),                                   \
++           "=&r" ((USItype) (__r))                                    \
++         : "r" ((USItype) (__d)),                                     \
++           "1" ((USItype) (__n1)),                                    \
++           "0" ((USItype) (__n0)) : "g1" __AND_CLOBBER_CC)
++#define UDIV_TIME (3+7*32)    /* 7 instructions/iteration. 32 iterations.  */
++#endif /* __sparclite__ */
++#endif /* __sparc_v8__ */
++#endif /* sparc32 */
++
++#if ((defined (__sparc__) && defined (__arch64__)) || defined (__sparcv9)) \
++    && W_TYPE_SIZE == 64
++#define add_ssaaaa(sh, sl, ah, al, bh, bl)                            \
++  __asm__ ("addcc %r4,%5,%1\n\t"                                      \
++         "add %r2,%3,%0\n\t"                                          \
++         "bcs,a,pn %%xcc, 1f\n\t"                                     \
++         "add %0, 1, %0\n"                                            \
++         "1:"                                                         \
++         : "=r" ((UDItype)(sh)),                                      \
++           "=&r" ((UDItype)(sl))                                      \
++         : "%rJ" ((UDItype)(ah)),                                     \
++           "rI" ((UDItype)(bh)),                                      \
++           "%rJ" ((UDItype)(al)),                                     \
++           "rI" ((UDItype)(bl))                                       \
++         __CLOBBER_CC)
++
++#define sub_ddmmss(sh, sl, ah, al, bh, bl)                            \
++  __asm__ ("subcc %r4,%5,%1\n\t"                                      \
++         "sub %r2,%3,%0\n\t"                                          \
++         "bcs,a,pn %%xcc, 1f\n\t"                                     \
++         "sub %0, 1, %0\n\t"                                          \
++         "1:"                                                         \
++         : "=r" ((UDItype)(sh)),                                      \
++           "=&r" ((UDItype)(sl))                                      \
++         : "rJ" ((UDItype)(ah)),                                      \
++           "rI" ((UDItype)(bh)),                                      \
++           "rJ" ((UDItype)(al)),                                      \
++           "rI" ((UDItype)(bl))                                       \
++         __CLOBBER_CC)
++
++#define umul_ppmm(wh, wl, u, v)                                               \
++  do {                                                                        \
++        UDItype tmp1, tmp2, tmp3, tmp4;                               \
++        __asm__ __volatile__ (                                        \
++                 "srl %7,0,%3\n\t"                                    \
++                 "mulx %3,%6,%1\n\t"                                  \
++                 "srlx %6,32,%2\n\t"                                  \
++                 "mulx %2,%3,%4\n\t"                                  \
++                 "sllx %4,32,%5\n\t"                                  \
++                 "srl %6,0,%3\n\t"                                    \
++                 "sub %1,%5,%5\n\t"                                   \
++                 "srlx %5,32,%5\n\t"                                  \
++                 "addcc %4,%5,%4\n\t"                                 \
++                 "srlx %7,32,%5\n\t"                                  \
++                 "mulx %3,%5,%3\n\t"                                  \
++                 "mulx %2,%5,%5\n\t"                                  \
++                 "sethi %%hi(0x80000000),%2\n\t"                      \
++                 "addcc %4,%3,%4\n\t"                                 \
++                 "srlx %4,32,%4\n\t"                                  \
++                 "add %2,%2,%2\n\t"                                   \
++                 "movcc %%xcc,%%g0,%2\n\t"                            \
++                 "addcc %5,%4,%5\n\t"                                 \
++                 "sllx %3,32,%3\n\t"                                  \
++                 "add %1,%3,%1\n\t"                                   \
++                 "add %5,%2,%0"                                       \
++         : "=r" ((UDItype)(wh)),                                      \
++           "=&r" ((UDItype)(wl)),                                     \
++           "=&r" (tmp1), "=&r" (tmp2), "=&r" (tmp3), "=&r" (tmp4)     \
++         : "r" ((UDItype)(u)),                                        \
++           "r" ((UDItype)(v))                                         \
++         __CLOBBER_CC);                                               \
++  } while (0)
++#define UMUL_TIME 96
++#define UDIV_TIME 230
++#endif /* sparc64 */
++
++#if defined (__vax__) && W_TYPE_SIZE == 32
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("addl2 %5,%1\n\tadwc %3,%0"                                        \
++         : "=g" ((USItype) (sh)),                                     \
++           "=&g" ((USItype) (sl))                                     \
++         : "%0" ((USItype) (ah)),                                     \
++           "g" ((USItype) (bh)),                                      \
++           "%1" ((USItype) (al)),                                     \
++           "g" ((USItype) (bl)))
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("subl2 %5,%1\n\tsbwc %3,%0"                                        \
++         : "=g" ((USItype) (sh)),                                     \
++           "=&g" ((USItype) (sl))                                     \
++         : "0" ((USItype) (ah)),                                      \
++           "g" ((USItype) (bh)),                                      \
++           "1" ((USItype) (al)),                                      \
++           "g" ((USItype) (bl)))
++#define umul_ppmm(xh, xl, m0, m1) \
++  do {                                                                        \
++    union {                                                           \
++      UDItype __ll;                                                   \
++      struct {USItype __l, __h;} __i;                                 \
++      } __xx;                                                         \
++    USItype __m0 = (m0), __m1 = (m1);                                 \
++    __asm__ ("emul %1,%2,$0,%0"                                               \
++           : "=r" (__xx.__ll)                                         \
++           : "g" (__m0),                                              \
++             "g" (__m1));                                             \
++    (xh) = __xx.__i.__h;                                              \
++    (xl) = __xx.__i.__l;                                              \
++    (xh) += ((((SItype) __m0 >> 31) & __m1)                           \
++           + (((SItype) __m1 >> 31) & __m0));                         \
++  } while (0)
++#define sdiv_qrnnd(q, r, n1, n0, d) \
++  do {                                                                        \
++    union {DItype __ll;                                                       \
++         struct {SItype __l, __h;} __i;                               \
++        } __xx;                                                       \
++    __xx.__i.__h = n1; __xx.__i.__l = n0;                             \
++    __asm__ ("ediv %3,%2,%0,%1"                                               \
++           : "=g" (q), "=g" (r)                                       \
++           : "g" (__xx.__ll), "g" (d));                               \
++  } while (0)
++#endif /* __vax__ */
++
++#if defined (__z8000__) && W_TYPE_SIZE == 16
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  __asm__ ("add       %H1,%H5\n\tadc  %H0,%H3"                                \
++         : "=r" ((unsigned int)(sh)),                                 \
++           "=&r" ((unsigned int)(sl))                                 \
++         : "%0" ((unsigned int)(ah)),                                 \
++           "r" ((unsigned int)(bh)),                                  \
++           "%1" ((unsigned int)(al)),                                 \
++           "rQR" ((unsigned int)(bl)))
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  __asm__ ("sub       %H1,%H5\n\tsbc  %H0,%H3"                                \
++         : "=r" ((unsigned int)(sh)),                                 \
++           "=&r" ((unsigned int)(sl))                                 \
++         : "0" ((unsigned int)(ah)),                                  \
++           "r" ((unsigned int)(bh)),                                  \
++           "1" ((unsigned int)(al)),                                  \
++           "rQR" ((unsigned int)(bl)))
++#define umul_ppmm(xh, xl, m0, m1) \
++  do {                                                                        \
++    union {long int __ll;                                             \
++         struct {unsigned int __h, __l;} __i;                         \
++        } __xx;                                                       \
++    unsigned int __m0 = (m0), __m1 = (m1);                            \
++    __asm__ ("mult    %S0,%H3"                                        \
++           : "=r" (__xx.__i.__h),                                     \
++             "=r" (__xx.__i.__l)                                      \
++           : "%1" (__m0),                                             \
++             "rQR" (__m1));                                           \
++    (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;                         \
++    (xh) += ((((signed int) __m0 >> 15) & __m1)                               \
++           + (((signed int) __m1 >> 15) & __m0));                     \
++  } while (0)
++#endif /* __z8000__ */
++
++#endif /* __GNUC__ */
++
++/* If this machine has no inline assembler, use C macros.  */
++
++#if !defined (add_ssaaaa)
++#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
++  do {                                                                        \
++    UWtype __x;                                                               \
++    __x = (al) + (bl);                                                        \
++    (sh) = (ah) + (bh) + (__x < (al));                                        \
++    (sl) = __x;                                                               \
++  } while (0)
++#endif
++
++#if !defined (sub_ddmmss)
++#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
++  do {                                                                        \
++    UWtype __x;                                                               \
++    __x = (al) - (bl);                                                        \
++    (sh) = (ah) - (bh) - (__x > (al));                                        \
++    (sl) = __x;                                                               \
++  } while (0)
++#endif
++
++/* If we lack umul_ppmm but have smul_ppmm, define umul_ppmm in terms of
++   smul_ppmm.  */
++#if !defined (umul_ppmm) && defined (smul_ppmm)
++#define umul_ppmm(w1, w0, u, v)                                               \
++  do {                                                                        \
++    UWtype __w1;                                                      \
++    UWtype __xm0 = (u), __xm1 = (v);                                  \
++    smul_ppmm (__w1, w0, __xm0, __xm1);                                       \
++    (w1) = __w1 + (-(__xm0 >> (W_TYPE_SIZE - 1)) & __xm1)             \
++              + (-(__xm1 >> (W_TYPE_SIZE - 1)) & __xm0);              \
++  } while (0)
++#endif
++
++/* If we still don't have umul_ppmm, define it using plain C.  */
++#if !defined (umul_ppmm)
++#define umul_ppmm(w1, w0, u, v)                                               \
++  do {                                                                        \
++    UWtype __x0, __x1, __x2, __x3;                                    \
++    UHWtype __ul, __vl, __uh, __vh;                                   \
++                                                                      \
++    __ul = __ll_lowpart (u);                                          \
++    __uh = __ll_highpart (u);                                         \
++    __vl = __ll_lowpart (v);                                          \
++    __vh = __ll_highpart (v);                                         \
++                                                                      \
++    __x0 = (UWtype) __ul * __vl;                                      \
++    __x1 = (UWtype) __ul * __vh;                                      \
++    __x2 = (UWtype) __uh * __vl;                                      \
++    __x3 = (UWtype) __uh * __vh;                                      \
++                                                                      \
++    __x1 += __ll_highpart (__x0);/* this can't give carry */          \
++    __x1 += __x2;             /* but this indeed can */               \
++    if (__x1 < __x2)          /* did we get it? */                    \
++      __x3 += __ll_B;         /* yes, add it in the proper pos.  */   \
++                                                                      \
++    (w1) = __x3 + __ll_highpart (__x1);                                       \
++    (w0) = __ll_lowpart (__x1) * __ll_B + __ll_lowpart (__x0);                \
++  } while (0)
++#endif
++
++#if !defined (__umulsidi3)
++#define __umulsidi3(u, v) \
++  ({DWunion __w;                                                      \
++    umul_ppmm (__w.s.high, __w.s.low, u, v);                          \
++    __w.ll; })
++#endif
++
++/* Define this unconditionally, so it can be used for debugging.  */
++#define __udiv_qrnnd_c(q, r, n1, n0, d) \
++  do {                                                                        \
++    UWtype __d1, __d0, __q1, __q0;                                    \
++    UWtype __r1, __r0, __m;                                           \
++    __d1 = __ll_highpart (d);                                         \
++    __d0 = __ll_lowpart (d);                                          \
++                                                                      \
++    __r1 = (n1) % __d1;                                                       \
++    __q1 = (n1) / __d1;                                                       \
++    __m = (UWtype) __q1 * __d0;                                               \
++    __r1 = __r1 * __ll_B | __ll_highpart (n0);                                \
++    if (__r1 < __m)                                                   \
++      {                                                                       \
++      __q1--, __r1 += (d);                                            \
++      if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\
++        if (__r1 < __m)                                               \
++          __q1--, __r1 += (d);                                        \
++      }                                                                       \
++    __r1 -= __m;                                                      \
++                                                                      \
++    __r0 = __r1 % __d1;                                                       \
++    __q0 = __r1 / __d1;                                                       \
++    __m = (UWtype) __q0 * __d0;                                               \
++    __r0 = __r0 * __ll_B | __ll_lowpart (n0);                         \
++    if (__r0 < __m)                                                   \
++      {                                                                       \
++      __q0--, __r0 += (d);                                            \
++      if (__r0 >= (d))                                                \
++        if (__r0 < __m)                                               \
++          __q0--, __r0 += (d);                                        \
++      }                                                                       \
++    __r0 -= __m;                                                      \
++                                                                      \
++    (q) = (UWtype) __q1 * __ll_B | __q0;                              \
++    (r) = __r0;                                                               \
++  } while (0)
++
++/* If the processor has no udiv_qrnnd but sdiv_qrnnd, go through
++   __udiv_w_sdiv (defined in libgcc or elsewhere).  */
++#if !defined (udiv_qrnnd) && defined (sdiv_qrnnd)
++#define udiv_qrnnd(q, r, nh, nl, d) \
++  do {                                                                        \
++    USItype __r;                                                      \
++    (q) = __udiv_w_sdiv (&__r, nh, nl, d);                            \
++    (r) = __r;                                                                \
++  } while (0)
++#endif
++
++/* If udiv_qrnnd was not defined for this processor, use __udiv_qrnnd_c.  */
++#if !defined (udiv_qrnnd)
++#define UDIV_NEEDS_NORMALIZATION 1
++#define udiv_qrnnd __udiv_qrnnd_c
++#endif
++
++#if !defined (count_leading_zeros)
++extern const UQItype __clz_tab[] ATTRIBUTE_HIDDEN;
++#define count_leading_zeros(count, x) \
++  do {                                                                        \
++    UWtype __xr = (x);                                                        \
++    UWtype __a;                                                               \
++                                                                      \
++    if (W_TYPE_SIZE <= 32)                                            \
++      {                                                                       \
++      __a = __xr < ((UWtype)1<<2*__BITS4)                             \
++        ? (__xr < ((UWtype)1<<__BITS4) ? 0 : __BITS4)                 \
++        : (__xr < ((UWtype)1<<3*__BITS4) ?  2*__BITS4 : 3*__BITS4);   \
++      }                                                                       \
++    else                                                              \
++      {                                                                       \
++      for (__a = W_TYPE_SIZE - 8; __a > 0; __a -= 8)                  \
++        if (((__xr >> __a) & 0xff) != 0)                              \
++          break;                                                      \
++      }                                                                       \
++                                                                      \
++    (count) = W_TYPE_SIZE - (__clz_tab[__xr >> __a] + __a);           \
++  } while (0)
++#define COUNT_LEADING_ZEROS_0 W_TYPE_SIZE
++#endif
++
++#if !defined (count_trailing_zeros)
++/* Define count_trailing_zeros using count_leading_zeros.  The latter might be
++   defined in asm, but if it is not, the C version above is good enough.  */
++#define count_trailing_zeros(count, x) \
++  do {                                                                        \
++    UWtype __ctz_x = (x);                                             \
++    UWtype __ctz_c;                                                   \
++    count_leading_zeros (__ctz_c, __ctz_x & -__ctz_x);                        \
++    (count) = W_TYPE_SIZE - 1 - __ctz_c;                              \
++  } while (0)
++#endif
++
++#ifndef UDIV_NEEDS_NORMALIZATION
++#define UDIV_NEEDS_NORMALIZATION 0
++#endif
diff --git a/palo-1.14-build.patch b/palo-1.14-build.patch
new file mode 100644 (file)
index 0000000..f86b40c
--- /dev/null
@@ -0,0 +1,29 @@
+--- palo/Makefile
++++ palo/Makefile
+@@ -11,10 +11,11 @@
+ OS := $(shell uname -s)
+ CC=gcc
++
++CFLAGS ?= -g -O
++CFLAGS += -I../include -I../lib
+ ifeq ($(strip ${OS}),HP-UX)
+-CFLAGS=-g -O -I../include -I../lib -I$(PA)/include
+-else
+-CFLAGS=-g -O -I../include -I../lib
++CFLAGS += -I$(PA)/include
+ endif
+ # LDFLAGS=-Wl,-Bstatic 
+--- ipl/Makefile
++++ ipl/Makefile
+@@ -21,7 +21,8 @@
+ # Source sharing with palo
+ VPATH=../lib:.
+-CFLAGS        = -I. -I../lib -I../include -O2 -mdisable-fpregs -Wall
++CFLAGS ?= -O2
++CFLAGS += -I. -I../lib -I../include