Switch over m68k soffloat build to libc/softfloat.

m68k would previously use softfloat functions contained in libgcc_s.

This change aligns m68k with other platforms built with softfloat.

It is still possible to build the gcc_s softfloat impementation by setting
MKSOFFTFLOAT=yes MKLIBCSOFTFLOAT=no

Addresses PR/59393.

Add generic flt_rounds for softfloat.

Note the m68k definitions are reversed as found via test results.

Switch over m68k soffloat build to libc/softfloat.

m68k would previously use softfloat functions contained in libgcc_s.

This change aligns m68k with other platforms built with softfloat.

It is still possible to build the gcc_s softfloat impementation by setting
MKSOFFTFLOAT=yes MKLIBCSOFTFLOAT=no

Addresses PR/59393.

remove some more GCC 4.5 code. make GCC 5.3 be HAVE_GCC=53, so that,
for example, HAVE_GCC >= 48 works properly.

Restrict the arm compiler optimization hack to gcc 4.5

branches: 1.19.2;
MKCOMPAT fixes for when compat MACHINE_CPU != normal MACHINE_CPU

remove remaining makefile support for GCC < 45 that i found.

branches: 1.17.2;
Add unordtf2.c

Only apply -fno-tree-vrp for GCC.

Match against LIBC_MACHINE_ARCH for MKCOMPAT

Use MACHINE_ARCH, not MACHINE

ARM EABI needs different floating point comparision functions.

Fix make syntax problem by putting the condition on the same line as .elif.

For arm, add -fno-tree-vrp to COPTS when compiling softfloat.c.
Without -fno-tree-vrp, -INF + -INF returns 0 by adddf3.
Fixes PR#46953.

branches: 1.10.2; 1.10.4; 1.10.8; 1.10.10;
sh3 also needs -Wno-enum-compare here.

mips wants some -Wno-enum-compare here, too.

XXX: apply -Wno-error/friends to a few files

Add long double functions for eq,ne,gt,le,ge,lt,neg ops.

Fix typo in previous.

Assign quad / softfloat specific ${SRCS} to ${SRCS.quad} / ${SRCS.softfloat}
then append them to ${SRCS}. Those will be used to generate quad / softfloat
symbol lists.

branches: 1.4.40;
Add support to build the mac68k port with soft-float enabled (i.e., setting
MKSOFTFLOAT=yes). The main purpose of this feature is to let NetBSD work
in machines with the 68040LC chip (those that have the FPU bug).

All the work has been done by Bruce O'Neel <edoneel AT sdf.lonestar.org>,
with some very minor changes by me; the patches were being posted to the
port-mac68k mailing list. It has been tested for a long time by several
users, including me.

I have just verified that regular releases, as well as soft-float ones,
continue to build.

There have been no objections to this patch since I asked for them in July
in the port-mac68k list.

GCC-3 requires a libcall to support testing for unordered.

Import the 32-bit version of SoftFloat 2a and separate it and the 64-bit
version into different directories. Which version a given port uses is
controlled by the SOFTFLOAT_BITS make variable. This is set to 64 (which
uses the same code we had before) by default. 32-bit platforms that don't
need extended precision support might get better performance by using 32.

Set the ARM port to use the 32-bit version of SoftFloat, since this is more
than a factor of two faster than the 64-bit version. This should get the
floating-point performance back to what it was in 1.5.

branches: 1.1.4; 1.1.6;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

Import the 32-bit version of SoftFloat 2a and separate it and the 64-bit
version into different directories. Which version a given port uses is
controlled by the SOFTFLOAT_BITS make variable. This is set to 64 (which
uses the same code we had before) by default. 32-bit platforms that don't
need extended precision support might get better performance by using 32.

Set the ARM port to use the 32-bit version of SoftFloat, since this is more
than a factor of two faster than the 64-bit version. This should get the
floating-point performance back to what it was in 1.5.

branches: 1.1.4; 1.1.6;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Add long double functions for eq,ne,gt,le,ge,lt,neg ops.

Add generic flt_rounds for softfloat.

Note the m68k definitions are reversed as found via test results.

Fix build for gcc_s softfloat (m68k).

Now that almost all of libc/softfloat is not build when setting
LIBCSOFTFLOAT=no for m68k it was necessary to define missing variables.

Adresses PR/59393.

branches: 1.4.8;
Remove clause 3 and 4 from TNF licenses

branches: 1.3.32;
Add SIGFPE support to SoftFloat, so fpsetmask/fpgetmask now work. A new
variable, float_exception_mask (#defined to _softfloat_float_exception_mask)
contains the current exception mask.
Also make the argument to float_raise into an fp_except.
Also synchronise file header comments between files.

Add internal names for fp{get,set}{mask,round,sticky}(), and
externally-visible weak aliases for the internal names.

branches: 1.1.4; 1.1.6;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.3.8;
Remove clause 3 and 4 from TNF licenses

branches: 1.2.32;
Add internal names for fp{get,set}{mask,round,sticky}(), and
externally-visible weak aliases for the internal names.

branches: 1.1.4; 1.1.6;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.3.8;
Remove clause 3 and 4 from TNF licenses

branches: 1.2.32;
Add internal names for fp{get,set}{mask,round,sticky}(), and
externally-visible weak aliases for the internal names.

branches: 1.1.4; 1.1.6;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

Add hooks to softfloat to support per-lwp exception state.

branches: 1.4.4; 1.4.8; 1.4.28;
Remove clause 3 and 4 from TNF licenses

branches: 1.3.32;
Add SIGFPE support to SoftFloat, so fpsetmask/fpgetmask now work. A new
variable, float_exception_mask (#defined to _softfloat_float_exception_mask)
contains the current exception mask.
Also make the argument to float_raise into an fp_except.
Also synchronise file header comments between files.

Add internal names for fp{get,set}{mask,round,sticky}(), and
externally-visible weak aliases for the internal names.

branches: 1.1.4; 1.1.6;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

Add hooks to softfloat to support per-lwp exception state.

branches: 1.3.4; 1.3.8; 1.3.28;
Remove clause 3 and 4 from TNF licenses

branches: 1.2.32;
Add internal names for fp{get,set}{mask,round,sticky}(), and
externally-visible weak aliases for the internal names.

branches: 1.1.4; 1.1.6;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

Add hooks to softfloat to support per-lwp exception state.

branches: 1.3.4; 1.3.8; 1.3.28;
Remove clause 3 and 4 from TNF licenses

branches: 1.2.32;
Add internal names for fp{get,set}{mask,round,sticky}(), and
externally-visible weak aliases for the internal names.

branches: 1.1.4; 1.1.6;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Add long double functions for eq,ne,gt,le,ge,lt,neg ops.

Fix return values for softfloat functions to appease gcc.

Not sure if it is gcc and m68k only so it wrapped up in defines.

Only compile the floatx80-using functions if the arch in question
defines the FLOATX80 macro. Fixes build problem for arm ports.

Add support to build the mac68k port with soft-float enabled (i.e., setting
MKSOFTFLOAT=yes). The main purpose of this feature is to let NetBSD work
in machines with the 68040LC chip (those that have the FPU bug).

All the work has been done by Bruce O'Neel <edoneel AT sdf.lonestar.org>,
with some very minor changes by me; the patches were being posted to the
port-mac68k mailing list. It has been tested for a long time by several
users, including me.

I have just verified that regular releases, as well as soft-float ones,
continue to build.

There have been no objections to this patch since I asked for them in July
in the port-mac68k list.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Add long double functions for eq,ne,gt,le,ge,lt,neg ops.

Fix return values for softfloat functions to appease gcc.

Not sure if it is gcc and m68k only so it wrapped up in defines.

Only compile the floatx80-using functions if the arch in question
defines the FLOATX80 macro. Fixes build problem for arm ports.

Add support to build the mac68k port with soft-float enabled (i.e., setting
MKSOFTFLOAT=yes). The main purpose of this feature is to let NetBSD work
in machines with the 68040LC chip (those that have the FPU bug).

All the work has been done by Bruce O'Neel <edoneel AT sdf.lonestar.org>,
with some very minor changes by me; the patches were being posted to the
port-mac68k mailing list. It has been tested for a long time by several
users, including me.

I have just verified that regular releases, as well as soft-float ones,
continue to build.

There have been no objections to this patch since I asked for them in July
in the port-mac68k list.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Add long double functions for eq,ne,gt,le,ge,lt,neg ops.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Add long double functions for eq,ne,gt,le,ge,lt,neg ops.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Add long double functions for eq,ne,gt,le,ge,lt,neg ops.

Only compile the floatx80-using functions if the arch in question
defines the FLOATX80 macro. Fixes build problem for arm ports.

Add support to build the mac68k port with soft-float enabled (i.e., setting
MKSOFTFLOAT=yes). The main purpose of this feature is to let NetBSD work
in machines with the 68040LC chip (those that have the FPU bug).

All the work has been done by Bruce O'Neel <edoneel AT sdf.lonestar.org>,
with some very minor changes by me; the patches were being posted to the
port-mac68k mailing list. It has been tested for a long time by several
users, including me.

I have just verified that regular releases, as well as soft-float ones,
continue to build.

There have been no objections to this patch since I asked for them in July
in the port-mac68k list.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Add long double functions for eq,ne,gt,le,ge,lt,neg ops.

Fix return values for softfloat functions to appease gcc.

Not sure if it is gcc and m68k only so it wrapped up in defines.

Only compile the floatx80-using functions if the arch in question
defines the FLOATX80 macro. Fixes build problem for arm ports.

Add support to build the mac68k port with soft-float enabled (i.e., setting
MKSOFTFLOAT=yes). The main purpose of this feature is to let NetBSD work
in machines with the 68040LC chip (those that have the FPU bug).

All the work has been done by Bruce O'Neel <edoneel AT sdf.lonestar.org>,
with some very minor changes by me; the patches were being posted to the
port-mac68k mailing list. It has been tested for a long time by several
users, including me.

I have just verified that regular releases, as well as soft-float ones,
continue to build.

There have been no objections to this patch since I asked for them in July
in the port-mac68k list.

Only include <arm/aeabi.h> when __ARM_PCS_VFP is defined.

Make sure to <arm/aeabi.h> if we are doing using EABI.

ARM EABI needs different floating point comparision functions.

branches: 1.9.2;
ARM EABI (AAPCS) uses different names for the softfloat routines that
the normal GCC ones. So after we redefine softfloat's to be what (old) GCC
wants, we redefined the old GCC names to what ARM EABI want (but only if we
are using ARM EABI). We do this for routines not compiled by softfloat so
can just have these redefinitions in one place.

branches: 1.8.6;
Merge from matt-nb5-mips64.

branches: 1.7.40;
Add support to build the mac68k port with soft-float enabled (i.e., setting
MKSOFTFLOAT=yes). The main purpose of this feature is to let NetBSD work
in machines with the 68040LC chip (those that have the FPU bug).

All the work has been done by Bruce O'Neel <edoneel AT sdf.lonestar.org>,
with some very minor changes by me; the patches were being posted to the
port-mac68k mailing list. It has been tested for a long time by several
users, including me.

I have just verified that regular releases, as well as soft-float ones,
continue to build.

There have been no objections to this patch since I asked for them in July
in the port-mac68k list.

netbsd.org->NetBSD.org

Add SIGFPE support to SoftFloat, so fpsetmask/fpgetmask now work. A new
variable, float_exception_mask (#defined to _softfloat_float_exception_mask)
contains the current exception mask.
Also make the argument to float_raise into an fp_except.
Also synchronise file header comments between files.

Re-instate __fixunssfsi() and __fixunsdfsi(), but only for arm32 with a.out
binaries, because libc's provided them there forever.

branches: 1.3.2;
Revert previous change -- turned out I'd got my build environment in a twist.

Add fixunssfsi and fixunsdfsi. These are provided by libgcc2.c in GCC 2.95,
but not in EGCS.

This version of fixunssfsi is almost exactly the arm32 version. fixunsdfsi is
mostly based on fixdfsi, but with simplifications for 64-bit integers.

Only minimal testing has been applied so far.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

Import the 32-bit version of SoftFloat 2a and separate it and the 64-bit
version into different directories. Which version a given port uses is
controlled by the SOFTFLOAT_BITS make variable. This is set to 64 (which
uses the same code we had before) by default. 32-bit platforms that don't
need extended precision support might get better performance by using 32.

Set the ARM port to use the 32-bit version of SoftFloat, since this is more
than a factor of two faster than the 64-bit version. This should get the
floating-point performance back to what it was in 1.5.

Rename a local variable to avoid a shadow decl warning.

Only include roundAndPackInt32(), roundAndPackInt64() and estimateSqrt32()
if we actually need them for 80/128-bit support.

I'm not sure this is Right, but I suspect the #ifdefs around here need
revising to handle sparc64 nicely anyway. Still, it compiles on ARM again
now.

Unblock a few routines that are needed if 128bit support is being pulled in.

branches: 1.1.4; 1.1.6;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

fix spelling of accommodate; from Zapher.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

Fix logic pertaining to NaN for floatx80.

The previous was wrong in that low and high were mixed up.

The only exisiting consumer on floatx80 types and softfloat is m68k.

Shift the high word of floatx80 accordingly on m68k.

This is because gcc will store floatx80 as signbit(1)exponent(15) padding(32)
as opposed to sign and exponent in a short(16 bit) word.

Switch over m68k soffloat build to libc/softfloat.

m68k would previously use softfloat functions contained in libgcc_s.

This change aligns m68k with other platforms built with softfloat.

It is still possible to build the gcc_s softfloat impementation by setting
MKSOFFTFLOAT=yes MKLIBCSOFTFLOAT=no

Addresses PR/59393.

libc: Sprinkle #ifdef _REENTRANT around thr_sigsetmask.

Workaround -- temporary, I hope -- for:

PR lib/59401: libc: thr_sigsetmask definition is incoherent

libc softfloat: Make SIGFPE for trapped fp exceptions non-ignorable.

In hardfloat, when the kernel delivers SIGFPE for a floating-point
exception trap, if SIGFPE is masked or ignored, it is handled _as if_
SIGFPE were unmasked and had the default signal disposition:

964 /*
965 * If the signal is masked or ignored, then unmask it and
966 * reset it to the default action so that the process or
967 * its tracer will be notified.
968 */
969 const bool ignored = action == SIG_IGN;
970 if (masked || ignored) {
971 mutex_enter(&ps->sa_mutex);
972 sigdelset(mask, signo);
973 sigdelset(&p->p_sigctx.ps_sigcatch, signo);
974 sigdelset(&p->p_sigctx.ps_sigignore, signo);
975 sigdelset(&SIGACTION_PS(ps, signo).sa_mask, signo);
976 SIGACTION_PS(ps, signo).sa_handler = SIG_DFL;
977 mutex_exit(&ps->sa_mutex);
978 }

https://nxr.netbsd.org/xref/src/sys/kern/kern_sig.c?r=1.410#964

In other words, if you have asked for floating-point exception traps
via fpsetmask(3) or feeenableexcept(3), then you can't simply defer
or ignore them at the signal level any more than you can defer or
ignore SIGBUS or SIGSEGV. And if the signal handler returns, it will
restart the instruction and -- if nothing has changed in the set of
trapped floating-point exceptions -- trap again, delivering the same
signal again.

Since we can't lock access to signal dispositions, I don't think we
can guarantee the same effect from userland atomically, but we can
get a close approximation (should be good enough for single-threaded
programs, at least) by mimicking this logic and calling sigqueueinfo
in a loop.

PR misc/56820: Many FPE related tests fail on softfloat machines

branches: 1.9.36;
Changes to existing files to enable building AARCH64 userland.
evbarm64-el
This is clang only. While gcc4.8 supports aarch64, no netbsd support has
been written for aarch64 with gcc4.8.

Add hooks to softfloat to support per-lwp exception state.

branches: 1.7.2;
cast to appropriate types.

branches: 1.6.4;
Apply local namespace protection equivalent to the weak alias done
in softfloat-for-gcc.h, which we can't include here, to move
"float_exception_mask" into implementation namespace.

Use sigqueueinfo() instead of raise() to generate exceptions. Provide
minimalistic siginfo data.

branches: 1.4.46;
Add support to build the mac68k port with soft-float enabled (i.e., setting
MKSOFTFLOAT=yes). The main purpose of this feature is to let NetBSD work
in machines with the 68040LC chip (those that have the FPU bug).

All the work has been done by Bruce O'Neel <edoneel AT sdf.lonestar.org>,
with some very minor changes by me; the patches were being posted to the
port-mac68k mailing list. It has been tested for a long time by several
users, including me.

I have just verified that regular releases, as well as soft-float ones,
continue to build.

There have been no objections to this patch since I asked for them in July
in the port-mac68k list.

Add SIGFPE support to SoftFloat, so fpsetmask/fpgetmask now work. A new
variable, float_exception_mask (#defined to _softfloat_float_exception_mask)
contains the current exception mask.
Also make the argument to float_raise into an fp_except.
Also synchronise file header comments between files.

branches: 1.2.2;
After the grand unification of softfloat-specialize, let sparc64 builds
work properly again.

All the versions of softfloat-specialize were practically identical, so replace
them with a single one.

Import the 32-bit version of SoftFloat 2a and separate it and the 64-bit
version into different directories. Which version a given port uses is
controlled by the SOFTFLOAT_BITS make variable. This is set to 64 (which
uses the same code we had before) by default. 32-bit platforms that don't
need extended precision support might get better performance by using 32.

Set the ARM port to use the 32-bit version of SoftFloat, since this is more
than a factor of two faster than the 64-bit version. This should get the
floating-point performance back to what it was in 1.5.

In float*_round_to_int(), where we have switches over rounding modes, make
sure that all the modes are mentioned, if only with a "break;". This
ensures GCC doesn't whinge at us on ports which use an enum for fp_rnd.

Consistently declare the types of float_rounding_mode and float_exception_flags
as fp_rnd and fp_except respectively.

Only include roundAndPackInt32(), roundAndPackInt64() and estimateSqrt32()
if we actually need them for 80/128-bit support.

I'm not sure this is Right, but I suspect the #ifdefs around here need
revising to handle sparc64 nicely anyway. Still, it compiles on ARM again
now.

Unblock a few routines that are needed if 128bit support is being pulled in.

fix WARNS triggered by reachover makefile under regress

Re-instate __fixunssfsi() and __fixunsdfsi(), but only for arm32 with a.out
binaries, because libc's provided them there forever.

branches: 1.3.2;
Revert previous change -- turned out I'd got my build environment in a twist.

Add fixunssfsi and fixunsdfsi. These are provided by libgcc2.c in GCC 2.95,
but not in EGCS.

This version of fixunssfsi is almost exactly the arm32 version. fixunsdfsi is
mostly based on fixdfsi, but with simplifications for 64-bit integers.

Only minimal testing has been applied so far.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

fix spelling of accommodate; from Zapher.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

Fix typo in the document. From FreeBSD.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

GCC-3 requires a libcall to support testing for unordered.

GCC-3 requires a libcall to support testing for unordered.

branches: 1.2.4; 1.2.8;
Make confiditon on FLOAT128

unord for float128 long double

fix -Wsign-compare issue (seen on arm), using similar technique
to ../bits64/softfloat-macros

branches: 1.1.4; 1.1.46; 1.1.50;
Import the 32-bit version of SoftFloat 2a and separate it and the 64-bit
version into different directories. Which version a given port uses is
controlled by the SOFTFLOAT_BITS make variable. This is set to 64 (which
uses the same code we had before) by default. 32-bit platforms that don't
need extended precision support might get better performance by using 32.

Set the ARM port to use the 32-bit version of SoftFloat, since this is more
than a factor of two faster than the 64-bit version. This should get the
floating-point performance back to what it was in 1.5.

Add hooks to softfloat to support per-lwp exception state.

branches: 1.2.2;
add casts

branches: 1.1.4; 1.1.60;
Import the 32-bit version of SoftFloat 2a and separate it and the 64-bit
version into different directories. Which version a given port uses is
controlled by the SOFTFLOAT_BITS make variable. This is set to 64 (which
uses the same code we had before) by default. 32-bit platforms that don't
need extended precision support might get better performance by using 32.

Set the ARM port to use the 32-bit version of SoftFloat, since this is more
than a factor of two faster than the 64-bit version. This should get the
floating-point performance back to what it was in 1.5.

cast to appropriate types.

branches: 1.2.6;
fix -Wsign-compare issue (on sparc64)

branches: 1.1.4; 1.1.46; 1.1.50;
Import the 32-bit version of SoftFloat 2a and separate it and the 64-bit
version into different directories. Which version a given port uses is
controlled by the SOFTFLOAT_BITS make variable. This is set to 64 (which
uses the same code we had before) by default. 32-bit platforms that don't
need extended precision support might get better performance by using 32.

Set the ARM port to use the 32-bit version of SoftFloat, since this is more
than a factor of two faster than the 64-bit version. This should get the
floating-point performance back to what it was in 1.5.

Fix thinko.

Change the remainder of missed INFs for floatx80.

Return the right value for infinity for floatx80.

There are only 5 failures and 1 expected failure left.

Fix return values for softfloat functions to appease gcc.

Not sure if it is gcc and m68k only so it wrapped up in defines.

Shift the high word of floatx80 accordingly on m68k.

This is because gcc will store floatx80 as signbit(1)exponent(15) padding(32)
as opposed to sign and exponent in a short(16 bit) word.

appease lint

Avoid warnings (signed/unsigned comparision and unused variable)

Fix a cast from the lint cleanup that made small exponents (i.e. values < 1)
sign extend wrong and overflow, causing an underflow in all 128 bit sqrt
calculations.

Add hooks to softfloat to support per-lwp exception state.

branches: 1.11.2;
Fix a bug introduced by lint cleanup.

cast to appropriate types.

Remove initialized but unused variable

branches: 1.8.2;
Fix so that float128_to_uint64_round_to_zero is defined for sparc64.
(isn't tha a namespace violation?)

Add SOFTFLOAT_NEED_FIXUNS condition around the float128 fixuns

Add __floatunsidf __floatunsisf __floatunsitf routines.
XXX i think they are correct but not sure.

branches: 1.5.20;
When creating unsigned int results, do not distinguish positive versus
negative overflow.

When converting long double values to integer types, explicitly use the
"round to zero" variants of the softfloat conversion functions.
Add a variant to convert long double to unsigned long - the "to long"
variant checked for overflows that do not apply to unsigned results.
This fixes the regress/lib/libc/convfp tests for sparc64.

branches: 1.3.10;
add128() wants bits64 * as it's 5th argument.

netbsd.org->NetBSD.org

branches: 1.1.4;
Import the 32-bit version of SoftFloat 2a and separate it and the 64-bit
version into different directories. Which version a given port uses is
controlled by the SOFTFLOAT_BITS make variable. This is set to 64 (which
uses the same code we had before) by default. 32-bit platforms that don't
need extended precision support might get better performance by using 32.

Set the ARM port to use the 32-bit version of SoftFloat, since this is more
than a factor of two faster than the 64-bit version. This should get the
floating-point performance back to what it was in 1.5.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.

branches: 1.1.4;
Initial commit of SoftFloat 2a import. This should provide a sensible
mostly-MI floating-point implementation for use by gcc -msoft-float.
It's currently only used by arm26, but should be usable by other ports
without too much hacking, assuming doubles and u_int64_ts are passed and
returned the same way, and FP formats are IEEEish.