--- gcc-3.4.3/gcc/Makefile.in

 +++ gcc-3.4.3-nios2/gcc/Makefile.in

 @@ -3085,7 +3085,7 @@ install-mkheaders: stmp-int-hdrs $(STMP_

  	  $(INSTALL_DATA) $(srcdir)/README-fixinc \

  	    $(DESTDIR)$(itoolsdatadir)/include/README ; \

  	  $(INSTALL_SCRIPT) fixinc.sh $(DESTDIR)$(itoolsdir)/fixinc.sh ; \

 -	  $(INSTALL_PROGRAM) fixinc/fixincl $(DESTDIR)$(itoolsdir)/fixincl ; \

 +	  $(INSTALL_PROGRAM) fixinc/fixincl$(build_exeext) $(DESTDIR)$(itoolsdir)/fixincl$(build_exeext) ; \

  	  $(INSTALL_DATA) $(srcdir)/gsyslimits.h \

  	    $(DESTDIR)$(itoolsdatadir)/gsyslimits.h ; \

  	else :; fi

 --- gcc-3.4.3/gcc/combine.c

 +++ gcc-3.4.3-nios2/gcc/combine.c

 @@ -4380,6 +4380,14 @@ combine_simplify_rtx (rtx x, enum machin

  					 mode);

  	    }

 +#ifndef __nios2__

 +/* This screws up Nios II in this test case:

 +

 +if (x & 1)

 +  return 2;

 +else

 +  return 3;

 +*/

  	  else if (STORE_FLAG_VALUE == 1

  		   && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT

  		   && op1 == const0_rtx

 @@ -4391,6 +4399,7 @@ combine_simplify_rtx (rtx x, enum machin

  				 gen_lowpart_for_combine (mode, op0),

  				 const1_rtx);

  	    }

 +#endif

  	  else if (STORE_FLAG_VALUE == 1

  		   && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT

 --- gcc-3.4.3/gcc/config/nios2/crti.asm

 +++ gcc-3.4.3-nios2/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-3.4.3/gcc/config/nios2/crtn.asm

 +++ gcc-3.4.3-nios2/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-3.4.3/gcc/config/nios2/lib2-divmod-hi.c

 +++ gcc-3.4.3-nios2/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-3.4.3/gcc/config/nios2/lib2-divmod.c

 +++ gcc-3.4.3-nios2/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-3.4.3/gcc/config/nios2/lib2-divtable.c

 +++ gcc-3.4.3-nios2/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-3.4.3/gcc/config/nios2/lib2-mul.c

 +++ gcc-3.4.3-nios2/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-3.4.3/gcc/config/nios2/nios2-dp-bit.c

 +++ gcc-3.4.3-nios2/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-3.4.3/gcc/config/nios2/nios2-fp-bit.c

 +++ gcc-3.4.3-nios2/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));