Import of gpl'ed math emulator.

No changes have been done.

44 files changed, 11697 insertions, 0 deletions

diff --git a/sys/gnu/i386/fpemul/Changelog b/sys/gnu/i386/fpemul/Changelog
new file mode 100644
index 0000000..a2fbccd1
--- /dev/null
+++ b/sys/gnu/i386/fpemul/Changelog
@@ -0,0 +1,36 @@
+This file contains the changes made to W. Metzenthem's 387 FPU
+emulator to make it work under NetBSD.
+
+a, Changes to make it compile:
+	
+	1 - Changed the #include's to get the appropriate .h files.
+	2 - Renamed .S to .s, to satisfy the kernel Makefile.
+	3 - Changed the C++ style // comments to /* */
+	4 - Changed the FPU_ORIG_EIP macro. A letter from bde included
+		in the package suggested using tf_isp for using instead
+		of the linux __orig_eip. This later turned out to interfere
+		with the user stack, so i created a separate variable, stored
+		in the i387_union.
+	5 - Changed the get_fs_.. put_fs_.. fns to fubyte,fuword,subyte,
+		suword.
+	6 - Removed the verify_area fns. I don't really know what they do,
+		i suppose they verify access to memory. The sufu routines
+		should do this.
+
+b, Changes to make it work:
+	
+	1 - Made math_emulate() to return 0 when successful, so trap() won't
+		try to generate a signal.
+	2 - Changed the size of the save87 struct in /sys/arch/i387/include/
+		npx.h to accomodate the i387_union.
+	
+d, Other changes:
+
+	1 - Removed obsolate and/or linux specific stuff.
+	2 - Changed the RE_ENTRANT_CHECK_[ON|OFF] macro to
+		REENTRANT_CHECK([ON|OFF]) so indent can grok it.
+	3 - Re-indented to Berkeley style.
+	4 - Limited max no of lookaheads. LOOKAHEAD_LIMIT in fpu_entry.c
+
+
+	Szabolcs Szigeti (pink@fsz.bme.hu)
diff --git a/sys/gnu/i386/fpemul/README b/sys/gnu/i386/fpemul/README
new file mode 100644
index 0000000..4982c35
--- /dev/null
+++ b/sys/gnu/i386/fpemul/README
@@ -0,0 +1,267 @@
+/*
+ *  wm-FPU-emu   an FPU emulator for 80386 and 80486SX microprocessors.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+wm-FPU-emu is an FPU emulator for Linux. It is derived from wm-emu387
+which is my 80387 emulator for djgpp (gcc under msdos); wm-emu387 was
+in turn based upon emu387 which was written by DJ Delorie for djgpp.
+The interface to the Linux kernel is based upon the original Linux
+math emulator by Linus Torvalds.
+
+My target FPU for wm-FPU-emu is that described in the Intel486
+Programmer's Reference Manual (1992 edition). Numerous facets of the
+functioning of the FPU are not well covered in the Reference Manual;
+in the absence of clear details I have made guesses about the most
+reasonable behaviour. Recently, this situation has improved because
+I now have some access to the results produced by a real 80486 FPU.
+
+wm-FPU-emu does not implement all of the behaviour of the 80486 FPU. 
+See "Limitations" later in this file for a partial list of some
+differences.  I believe that the missing features are never used by
+normal C or FORTRAN programs. 
+
+
+Please report bugs, etc to me at:
+       apm233m@vaxc.cc.monash.edu.au
+
+
+--Bill Metzenthen
+  May 1993
+
+
+----------------------- Internals of wm-FPU-emu -----------------------
+
+Numeric algorithms:
+(1) Add, subtract, and multiply. Nothing remarkable in these.
+(2) Divide has been tuned to get reasonable performance. The algorithm
+    is not the obvious one which most people seem to use, but is designed
+    to take advantage of the characteristics of the 80386. I expect that
+    it has been invented many times before I discovered it, but I have not
+    seen it. It is based upon one of those ideas which one carries around
+    for years without ever bothering to check it out.
+(3) The sqrt function has been tuned to get good performance. It is based
+    upon Newton's classic method. Performance was improved by capitalizing
+    upon the properties of Newton's method, and the code is once again
+    structured taking account of the 80386 characteristics.
+(4) The trig, log, and exp functions are based in each case upon quasi-
+    "optimal" polynomial approximations. My definition of "optimal" was
+    based upon getting good accuracy with reasonable speed.
+
+The code of the emulator is complicated slightly by the need to
+account for a limited form of re-entrancy. Normally, the emulator will
+emulate each FPU instruction to completion without interruption.
+However, it may happen that when the emulator is accessing the user
+memory space, swapping may be needed. In this case the emulator may be
+temporarily suspended while disk i/o takes place. During this time
+another process may use the emulator, thereby changing some static
+variables (eg FPU_st0_ptr, etc). The code which accesses user memory
+is confined to five files:
+    fpu_entry.c
+    reg_ld_str.c
+    load_store.c
+    get_address.c
+    errors.c
+
+----------------------- Limitations of wm-FPU-emu -----------------------
+
+There are a number of differences between the current wm-FPU-emu
+(version beta 1.4) and the 80486 FPU (apart from bugs). Some of the
+more important differences are listed below:
+
+All internal computations are performed at 64 bit or higher precision
+and rounded etc as required by the PC bits of the FPU control word.
+Under the crt0 version for Linux current at March 1993, the FPU PC
+bits specify 53 bits precision.
+
+The precision flag (PE of the FPU status word) and the Roundup flag
+(C1 of the status word) are now partially implemented. Does anyone
+write code which uses these features?
+
+The functions which load/store the FPU state are partially implemented,
+but the implementation should be sufficient for handling FPU errors etc
+in 32 bit protected mode.
+
+The implementation of the exception mechanism is flawed for unmasked
+interrupts.
+
+Detection of certain conditions, such as denormal operands, is not yet
+complete.
+
+----------------------- Performance of wm-FPU-emu -----------------------
+
+Speed.
+-----
+
+The speed of floating point computation with the emulator will depend
+upon instruction mix. Relative performance is best for the instructions
+which require most computation. The simple instructions are adversely
+affected by the fpu instruction trap overhead.
+
+
+Timing: Some simple timing tests have been made on the emulator functions.
+The times include load/store instructions. All times are in microseconds
+measured on a 33MHz 386 with 64k cache. The Turbo C tests were under
+ms-dos, the next two columns are for emulators running with the djgpp
+ms-dos extender. The final column is for wm-FPU-emu in Linux 0.97,
+using libm4.0 (hard).
+
+function      Turbo C        djgpp 1.06        WM-emu387     wm-FPU-emu
+
+   +          60.5           154.8              76.5          139.4
+   -          61.1-65.5      157.3-160.8        76.2-79.5     142.9-144.7
+   *          71.0           190.8              79.6          146.6
+   /          61.2-75.0      261.4-266.9        75.3-91.6     142.2-158.1
+
+ sin()        310.8          4692.0            319.0          398.5
+ cos()        284.4          4855.2            308.0          388.7
+ tan()        495.0          8807.1            394.9          504.7
+ atan()       328.9          4866.4            601.1          419.5-491.9
+
+ sqrt()       128.7          crashed           145.2          227.0
+ log()        413.1-419.1    5103.4-5354.21    254.7-282.2    409.4-437.1
+ exp()        479.1          6619.2            469.1          850.8
+
+
+The performance under Linux is improved by the use of look-ahead code.
+The following results show the improvement which is obtained under
+Linux due to the look-ahead code. Also given are the times for the
+original Linux emulator with the 4.1 'soft' lib.
+
+ [ Linus' note: I changed look-ahead to be the default under linux, as
+   there was no reason not to use it after I had edited it to be
+   disabled during tracing ]
+
+            wm-FPU-emu w     original w
+            look-ahead       'soft' lib
+   +         106.4             190.2
+   -         108.6-111.6      192.4-216.2
+   *         113.4             193.1
+   /         108.8-124.4      700.1-706.2
+
+ sin()       390.5            2642.0
+ cos()       381.5            2767.4
+ tan()       496.5            3153.3
+ atan()      367.2-435.5     2439.4-3396.8
+
+ sqrt()      195.1            4732.5
+ log()       358.0-387.5     3359.2-3390.3
+ exp()       619.3            4046.4
+
+
+These figures are now somewhat out-of-date. The emulator has become
+progressively slower for most functions as more of the 80486 features
+have been implemented.
+
+
+----------------------- Accuracy of wm-FPU-emu -----------------------
+
+
+Accuracy: The following table gives the accuracy of the sqrt(), trig
+and log functions. Each function was tested at about 400 points. Ideal
+results would be 64 bits. The reduced accuracy of cos() and tan() for
+arguments greater than pi/4 can be thought of as being due to the
+precision of the argument x; e.g. an argument of pi/2-(1e-10) which is
+accurate to 64 bits can result in a relative accuracy in cos() of about
+64 + log2(cos(x)) = 31 bits. Results for the Turbo C emulator are given
+in the last column.
+
+
+Function      Tested x range            Worst result (bits)         Turbo C
+
+sqrt(x)       1 .. 2                    64.1                         63.2
+atan(x)       1e-10 .. 200              62.6                         62.8
+cos(x)        0 .. pi/2-(1e-10)         63.2 (x <= pi/4)             62.4
+                                        35.2 (x = pi/2-(1e-10))      31.9
+sin(x)        1e-10 .. pi/2             63.0                         62.8
+tan(x)        1e-10 .. pi/2-(1e-10)     62.4 (x <= pi/4)             62.1
+                                        35.2 (x = pi/2-(1e-10))      31.9
+exp(x)        0 .. 1                    63.1                         62.9
+log(x)        1+1e-6 .. 2               62.4                         62.1
+
+
+As of version 1.3 of the emulator, the accuracy of the basic
+arithmetic has been improved (by a small fraction of a bit). Care has
+been taken to ensure full accuracy of the rounding of the basic
+arithmetic functions (+,-,*,/,and fsqrt), and they all now produce
+results which are exact to the 64th bit (unless there are any bugs
+left). To ensure this, it was necessary to effectively get information
+of up to about 128 bits precision. The emulator now passes the
+"paranoia" tests (compiled with gcc 2.3.3) for 'float' variables (24
+bit precision numbers) when precision control is set to 24, 53 or 64
+bits, and for 'double' variables (53 bit precision numbers) when
+precision control is set to 53 bits (a properly performing FPU cannot
+pass the 'paranoia' tests for 'double' variables when precision
+control is set to 64 bits).
+
+------------------------- Contributors -------------------------------
+
+A number of people have contributed to the development of the
+emulator, often by just reporting bugs, sometimes with a suggested
+fix, and a few kind people have provided me with access in one way or
+another to an 80486 machine. Contributors include (to those people who
+I have forgotten, please excuse me):
+
+Linus Torvalds
+Tommy.Thorn@daimi.aau.dk
+Andrew.Tridgell@anu.edu.au
+Nick Holloway alfie@dcs.warwick.ac.uk
+Hermano Moura moura@dcs.gla.ac.uk
+Jon Jagger J.Jagger@scp.ac.uk
+Lennart Benschop
+Brian Gallew geek+@CMU.EDU
+Thomas Staniszewski ts3v+@andrew.cmu.edu
+Martin Howell mph@plasma.apana.org.au
+M Saggaf alsaggaf@athena.mit.edu
+Peter Barker PETER@socpsy.sci.fau.edu
+tom@vlsivie.tuwien.ac.at
+Dan Russel russed@rpi.edu
+Daniel Carosone danielce@ee.mu.oz.au
+cae@jpmorgan.com
+Hamish Coleman t933093@minyos.xx.rmit.oz.au
+
+...and numerous others who responded to my request for help with
+a real 80486.
+
diff --git a/sys/gnu/i386/fpemul/bde_trapinfo.mail b/sys/gnu/i386/fpemul/bde_trapinfo.mail
new file mode 100644
index 0000000..2749e04
--- /dev/null
+++ b/sys/gnu/i386/fpemul/bde_trapinfo.mail
@@ -0,0 +1,35 @@
+From bde@kralizec.zeta.org.au  Sun Jun 27 01:18:32 1993
+Received: from ultima.socs.uts.EDU.AU by bsd.coe.montana.edu (5.67/KAOS-1)
+	id AA11952; Sun, 27 Jun 93 01:18:32 -0600
+Received: by ultima.socs.uts.EDU.AU (5.65+/SMI-3.3)
+	id AA03033; Sun, 27 Jun 93 17:10:22 +1000
+Received: by kralizec.zeta.org.au (4.0/SMI-4.0)
+	id AA15074; Sat, 26 Jun 93 02:32:58 EST
+Date: Sat, 26 Jun 93 02:32:58 EST
+From: bde@kralizec.zeta.org.au (Bruce Evans)
+Message-Id: <9306251632.AA15074@kralizec.zeta.org.au>
+To: nate@bsd.coe.montana.edu
+Subject: Re:  Trapframe information
+Status: OR
+
+tf_isp		original esp (probably spare - popal ignores it)
+tf_trapno	s/w trap no (may be spare - trap.c has already looked at it)
+tf_err		h/w error code (probably spare - gets discarded before iret)
+
+___fs		not stored in 386BSD pcb.  Constant anyway unless user has
+		screwed with it (?).
+___gs		ditto
+___orig_eip	in linux, this is on the stack just before the call to the
+		emulator.  The reason that it's not a local variable is to
+		avoid passing around pointers to it - current->frame (or
+		whatever) points to everything in the stack frame.  The
+		macros hide a lot of slow memory references
+		current->frame->var.
+
+>(And I need to see if I can map orig_eip to one of the three that I'm unsure of
+>in the BSD sources)
+
+tf_isp is the least evil.
+
+Bruce
+
diff --git a/sys/gnu/i386/fpemul/control_w.h b/sys/gnu/i386/fpemul/control_w.h
new file mode 100644
index 0000000..6d4ee24
--- /dev/null
+++ b/sys/gnu/i386/fpemul/control_w.h
@@ -0,0 +1,82 @@
+/*
+ *  control_w.h
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _CONTROLW_H_
+#define _CONTROLW_H_
+
+#ifdef LOCORE
+#define	_Const_(x)	$/**/x
+#else
+#define	_Const_(x)	x
+#endif
+
+#define CW_RC		_Const_(0x0C00)	/* rounding control */
+#define CW_PC		_Const_(0x0300)	/* precision control */
+
+#define CW_Precision	Const_(0x0020)	/* loss of precision mask */
+#define CW_Underflow	Const_(0x0010)	/* underflow mask */
+#define CW_Overflow	Const_(0x0008)	/* overflow mask */
+#define CW_ZeroDiv	Const_(0x0004)	/* divide by zero mask */
+#define CW_Denormal	Const_(0x0002)	/* denormalized operand mask */
+#define CW_Invalid	Const_(0x0001)	/* invalid operation mask */
+
+#define CW_Exceptions  	_Const_(0x003f)	/* all masks */
+
+#define RC_RND		_Const_(0x0000)
+#define RC_DOWN		_Const_(0x0400)
+#define RC_UP		_Const_(0x0800)
+#define RC_CHOP		_Const_(0x0C00)
+
+/* p 15-5: Precision control bits affect only the following:
+   ADD, SUB(R), MUL, DIV(R), and SQRT */
+#define PR_24_BITS      _Const_(0x000)
+#define PR_53_BITS      _Const_(0x200)
+#define PR_64_BITS      _Const_(0x300)
+/* FULL_PRECISION simulates all exceptions masked */
+#define FULL_PRECISION  (PR_64_BITS | RC_RND | 0x3f)
+
+#endif				/* _CONTROLW_H_ */
diff --git a/sys/gnu/i386/fpemul/div_small.s b/sys/gnu/i386/fpemul/div_small.s
new file mode 100644
index 0000000..13c2643
--- /dev/null
+++ b/sys/gnu/i386/fpemul/div_small.s
@@ -0,0 +1,88 @@
+	.file	"div_small.S"
+/*
+ *  div_small.S
+ *
+ * Divide a 64 bit integer by a 32 bit integer & return remainder.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*---------------------------------------------------------------------------+
+ |    unsigned long div_small(unsigned long long *x, unsigned long y)        |
+ +---------------------------------------------------------------------------*/
+
+#include "fpu_asm.h"
+
+.text
+	.align 2,144
+
+.globl _div_small
+
+_div_small:
+	pushl	%ebp
+	movl	%esp,%ebp
+
+	pushl	%esi
+
+	movl	PARAM1,%esi	/* pointer to num */
+	movl	PARAM2,%ecx	/* The denominator */
+
+	movl	4(%esi),%eax	/* Get the current num msw */
+	xorl	%edx,%edx
+	divl	%ecx
+
+	movl	%eax,4(%esi)
+
+	movl	(%esi),%eax	/* Get the num lsw */
+	divl	%ecx
+
+	movl	%eax,(%esi)
+
+	movl	%edx,%eax	/* Return the remainder in eax */
+
+	popl	%esi
+
+	leave
+	ret
+
diff --git a/sys/gnu/i386/fpemul/errors.c b/sys/gnu/i386/fpemul/errors.c
new file mode 100644
index 0000000..ed5ba47
--- /dev/null
+++ b/sys/gnu/i386/fpemul/errors.c
@@ -0,0 +1,599 @@
+/*
+ *  errors.c
+ *
+ *  The error handling functions for wm-FPU-emu
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*---------------------------------------------------------------------------+
+ | Note:                                                                     |
+ |    The file contains code which accesses user memory.                     |
+ |    Emulator static data may change when user memory is accessed, due to   |
+ |    other processes using the emulator while swapping is in progress.      |
+ +---------------------------------------------------------------------------*/
+
+
+
+
+
+#include "param.h"
+#include "proc.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "exception.h"
+#include "status_w.h"
+#include "control_w.h"
+#include "reg_constant.h"
+#include "version.h"
+
+/* */
+#undef PRINT_MESSAGES
+/* */
+
+
+void
+Un_impl(void)
+{
+	unsigned char byte1, FPU_modrm;
+
+	REENTRANT_CHECK(OFF);
+	byte1 = fubyte((unsigned char *) FPU_ORIG_EIP);
+	FPU_modrm = fubyte(1 + (unsigned char *) FPU_ORIG_EIP);
+
+	printf("Unimplemented FPU Opcode at eip=%p : %02x ",
+	    FPU_ORIG_EIP, byte1);
+
+	if (FPU_modrm >= 0300)
+		printf("%02x (%02x+%d)\n", FPU_modrm, FPU_modrm & 0xf8, FPU_modrm & 7);
+	else
+		printf("/%d\n", (FPU_modrm >> 3) & 7);
+	REENTRANT_CHECK(ON);
+
+	EXCEPTION(EX_Invalid);
+
+}
+
+
+
+
+void
+emu_printall()
+{
+	int     i;
+	static char *tag_desc[] = {"Valid", "Zero", "ERROR", "ERROR",
+	"DeNorm", "Inf", "NaN", "Empty"};
+	unsigned char byte1, FPU_modrm;
+
+	REENTRANT_CHECK(OFF);
+	byte1 = fubyte((unsigned char *) FPU_ORIG_EIP);
+	FPU_modrm = fubyte(1 + (unsigned char *) FPU_ORIG_EIP);
+
+#ifdef DEBUGGING
+	if (status_word & SW_Backward)
+		printf("SW: backward compatibility\n");
+	if (status_word & SW_C3)
+		printf("SW: condition bit 3\n");
+	if (status_word & SW_C2)
+		printf("SW: condition bit 2\n");
+	if (status_word & SW_C1)
+		printf("SW: condition bit 1\n");
+	if (status_word & SW_C0)
+		printf("SW: condition bit 0\n");
+	if (status_word & SW_Summary)
+		printf("SW: exception summary\n");
+	if (status_word & SW_Stack_Fault)
+		printf("SW: stack fault\n");
+	if (status_word & SW_Precision)
+		printf("SW: loss of precision\n");
+	if (status_word & SW_Underflow)
+		printf("SW: underflow\n");
+	if (status_word & SW_Overflow)
+		printf("SW: overflow\n");
+	if (status_word & SW_Zero_Div)
+		printf("SW: divide by zero\n");
+	if (status_word & SW_Denorm_Op)
+		printf("SW: denormalized operand\n");
+	if (status_word & SW_Invalid)
+		printf("SW: invalid operation\n");
+#endif				/* DEBUGGING */
+
+	status_word = status_word & ~SW_Top;
+	status_word |= (top & 7) << SW_Top_Shift;
+
+	printf("At %p: %02x ", FPU_ORIG_EIP, byte1);
+	if (FPU_modrm >= 0300)
+		printf("%02x (%02x+%d)\n", FPU_modrm, FPU_modrm & 0xf8, FPU_modrm & 7);
+	else
+		printf("/%d, mod=%d rm=%d\n",
+		    (FPU_modrm >> 3) & 7, (FPU_modrm >> 6) & 3, FPU_modrm & 7);
+
+	printf(" SW: b=%d st=%d es=%d sf=%d cc=%d%d%d%d ef=%d%d%d%d%d%d\n",
+	    status_word & 0x8000 ? 1 : 0,	/* busy */
+	    (status_word & 0x3800) >> 11,	/* stack top pointer */
+	    status_word & 0x80 ? 1 : 0,	/* Error summary status */
+	    status_word & 0x40 ? 1 : 0,	/* Stack flag */
+	    status_word & SW_C3 ? 1 : 0, status_word & SW_C2 ? 1 : 0,	/* cc */
+	    status_word & SW_C1 ? 1 : 0, status_word & SW_C0 ? 1 : 0,	/* cc */
+	    status_word & SW_Precision ? 1 : 0, status_word & SW_Underflow ? 1 : 0,
+	    status_word & SW_Overflow ? 1 : 0, status_word & SW_Zero_Div ? 1 : 0,
+	    status_word & SW_Denorm_Op ? 1 : 0, status_word & SW_Invalid ? 1 : 0);
+
+	printf(" CW: ic=%d rc=%d%d pc=%d%d iem=%d     ef=%d%d%d%d%d%d\n",
+	    control_word & 0x1000 ? 1 : 0,
+	    (control_word & 0x800) >> 11, (control_word & 0x400) >> 10,
+	    (control_word & 0x200) >> 9, (control_word & 0x100) >> 8,
+	    control_word & 0x80 ? 1 : 0,
+	    control_word & SW_Precision ? 1 : 0, control_word & SW_Underflow ? 1 : 0,
+	    control_word & SW_Overflow ? 1 : 0, control_word & SW_Zero_Div ? 1 : 0,
+	    control_word & SW_Denorm_Op ? 1 : 0, control_word & SW_Invalid ? 1 : 0);
+
+	for (i = 0; i < 8; i++) {
+		FPU_REG *r = &st(i);
+		switch (r->tag) {
+		case TW_Empty:
+			continue;
+			break;
+		case TW_Zero:
+			printf("st(%d)  %c .0000 0000 0000 0000         ",
+			    i, r->sign ? '-' : '+');
+			break;
+		case TW_Valid:
+		case TW_NaN:
+		case TW_Denormal:
+		case TW_Infinity:
+			printf("st(%d)  %c .%04x %04x %04x %04x e%+-6d ", i,
+			    r->sign ? '-' : '+',
+			    (long) (r->sigh >> 16),
+			    (long) (r->sigh & 0xFFFF),
+			    (long) (r->sigl >> 16),
+			    (long) (r->sigl & 0xFFFF),
+			    r->exp - EXP_BIAS + 1);
+			break;
+		default:
+			printf("Whoops! Error in errors.c      ");
+			break;
+		}
+		printf("%s\n", tag_desc[(int) (unsigned) r->tag]);
+	}
+
+	printf("[data] %c .%04x %04x %04x %04x e%+-6d ",
+	    FPU_loaded_data.sign ? '-' : '+',
+	    (long) (FPU_loaded_data.sigh >> 16),
+	    (long) (FPU_loaded_data.sigh & 0xFFFF),
+	    (long) (FPU_loaded_data.sigl >> 16),
+	    (long) (FPU_loaded_data.sigl & 0xFFFF),
+	    FPU_loaded_data.exp - EXP_BIAS + 1);
+	printf("%s\n", tag_desc[(int) (unsigned) FPU_loaded_data.tag]);
+	REENTRANT_CHECK(ON);
+
+}
+
+static struct {
+	int     type;
+	char   *name;
+}       exception_names[] = {
+	{
+		EX_StackOver, "stack overflow"
+	},
+	{
+		EX_StackUnder, "stack underflow"
+	},
+	{
+		EX_Precision, "loss of precision"
+	},
+	{
+		EX_Underflow, "underflow"
+	},
+	{
+		EX_Overflow, "overflow"
+	},
+	{
+		EX_ZeroDiv, "divide by zero"
+	},
+	{
+		EX_Denormal, "denormalized operand"
+	},
+	{
+		EX_Invalid, "invalid operation"
+	},
+	{
+		EX_INTERNAL, "INTERNAL BUG in " FPU_VERSION
+	},
+	{
+		0, NULL
+	}
+};
+/*
+ EX_INTERNAL is always given with a code which indicates where the
+ error was detected.
+
+ Internal error types:
+       0x14   in e14.c
+       0x1nn  in a *.c file:
+              0x101  in reg_add_sub.c
+              0x102  in reg_mul.c
+              0x103  in poly_sin.c
+              0x104  in poly_tan.c
+              0x105  in reg_mul.c
+	      0x106  in reg_mov.c
+              0x107  in fpu_trig.c
+	      0x108  in reg_compare.c
+	      0x109  in reg_compare.c
+	      0x110  in reg_add_sub.c
+	      0x111  in interface.c
+	      0x112  in fpu_trig.c
+	      0x113  in reg_add_sub.c
+	      0x114  in reg_ld_str.c
+	      0x115  in fpu_trig.c
+	      0x116  in fpu_trig.c
+	      0x117  in fpu_trig.c
+	      0x118  in fpu_trig.c
+	      0x119  in fpu_trig.c
+	      0x120  in poly_atan.c
+	      0x121  in reg_compare.c
+	      0x122  in reg_compare.c
+	      0x123  in reg_compare.c
+       0x2nn  in an *.s file:
+              0x201  in reg_u_add.S
+              0x202  in reg_u_div.S
+              0x203  in reg_u_div.S
+              0x204  in reg_u_div.S
+              0x205  in reg_u_mul.S
+              0x206  in reg_u_sub.S
+              0x207  in wm_sqrt.S
+	      0x208  in reg_div.S
+              0x209  in reg_u_sub.S
+              0x210  in reg_u_sub.S
+              0x211  in reg_u_sub.S
+              0x212  in reg_u_sub.S
+	      0x213  in wm_sqrt.S
+	      0x214  in wm_sqrt.S
+	      0x215  in wm_sqrt.S
+	      0x216  in reg_round.S
+	      0x217  in reg_round.S
+	      0x218  in reg_round.S
+ */
+
+void
+exception(int n)
+{
+	int     i, int_type;
+
+	int_type = 0;		/* Needed only to stop compiler warnings */
+	if (n & EX_INTERNAL) {
+		int_type = n - EX_INTERNAL;
+		n = EX_INTERNAL;
+		/* Set lots of exception bits! */
+		status_word |= (SW_Exc_Mask | SW_Summary | FPU_BUSY);
+	} else {
+		/* Extract only the bits which we use to set the status word */
+		n &= (SW_Exc_Mask);
+		/* Set the corresponding exception bit */
+		status_word |= n;
+		if (status_word & ~control_word & CW_Exceptions)
+			status_word |= SW_Summary;
+		if (n & (SW_Stack_Fault | EX_Precision)) {
+			if (!(n & SW_C1))
+				/* This bit distinguishes over- from underflow
+				 * for a stack fault, and roundup from
+				 * round-down for precision loss. */
+				status_word &= ~SW_C1;
+		}
+	}
+
+	REENTRANT_CHECK(OFF);
+	if ((~control_word & n & CW_Exceptions) || (n == EX_INTERNAL)) {
+#ifdef PRINT_MESSAGES
+		/* My message from the sponsor */
+		printf(FPU_VERSION " " __DATE__ " (C) W. Metzenthen.\n");
+#endif				/* PRINT_MESSAGES */
+
+		/* Get a name string for error reporting */
+		for (i = 0; exception_names[i].type; i++)
+			if ((exception_names[i].type & n) == exception_names[i].type)
+				break;
+
+		if (exception_names[i].type) {
+#ifdef PRINT_MESSAGES
+			printf("FP Exception: %s!\n", exception_names[i].name);
+#endif				/* PRINT_MESSAGES */
+		} else
+			printf("FP emulator: Unknown Exception: 0x%04x!\n", n);
+
+		if (n == EX_INTERNAL) {
+			printf("FP emulator: Internal error type 0x%04x\n", int_type);
+			emu_printall();
+		}
+#ifdef PRINT_MESSAGES
+		else
+			emu_printall();
+#endif				/* PRINT_MESSAGES */
+
+		/* The 80486 generates an interrupt on the next non-control
+		 * FPU instruction. So we need some means of flagging it. We
+		 * use the ES (Error Summary) bit for this, assuming that this
+		 * is the way a real FPU does it (until I can check it out),
+		 * if not, then some method such as the following kludge might
+		 * be needed. */
+/*      regs[0].tag |= TW_FPU_Interrupt; */
+	}
+	REENTRANT_CHECK(ON);
+
+#ifdef __DEBUG__
+	math_abort(SIGFPE);
+#endif				/* __DEBUG__ */
+
+}
+
+
+/* Real operation attempted on two operands, one a NaN */
+void
+real_2op_NaN(FPU_REG * a, FPU_REG * b, FPU_REG * dest)
+{
+	FPU_REG *x;
+	int     signalling;
+
+	x = a;
+	if (a->tag == TW_NaN) {
+		if (b->tag == TW_NaN) {
+			signalling = !(a->sigh & b->sigh & 0x40000000);
+			/* find the "larger" */
+			if (*(long long *) &(a->sigl) < *(long long *) &(b->sigl))
+				x = b;
+		} else {
+			/* return the quiet version of the NaN in a */
+			signalling = !(a->sigh & 0x40000000);
+		}
+	} else
+#ifdef PARANOID
+		if (b->tag == TW_NaN)
+#endif				/* PARANOID */
+		{
+			signalling = !(b->sigh & 0x40000000);
+			x = b;
+		}
+#ifdef PARANOID
+		else {
+			signalling = 0;
+			EXCEPTION(EX_INTERNAL | 0x113);
+			x = &CONST_QNaN;
+		}
+#endif				/* PARANOID */
+
+	if (!signalling) {
+		if (!(x->sigh & 0x80000000))	/* pseudo-NaN ? */
+			x = &CONST_QNaN;
+		reg_move(x, dest);
+		return;
+	}
+	if (control_word & CW_Invalid) {
+		/* The masked response */
+		if (!(x->sigh & 0x80000000))	/* pseudo-NaN ? */
+			x = &CONST_QNaN;
+		reg_move(x, dest);
+		/* ensure a Quiet NaN */
+		dest->sigh |= 0x40000000;
+	}
+	EXCEPTION(EX_Invalid);
+
+	return;
+}
+/* Invalid arith operation on Valid registers */
+void
+arith_invalid(FPU_REG * dest)
+{
+
+	if (control_word & CW_Invalid) {
+		/* The masked response */
+		reg_move(&CONST_QNaN, dest);
+	}
+	EXCEPTION(EX_Invalid);
+
+	return;
+
+}
+
+
+/* Divide a finite number by zero */
+void
+divide_by_zero(int sign, FPU_REG * dest)
+{
+
+	if (control_word & CW_ZeroDiv) {
+		/* The masked response */
+		reg_move(&CONST_INF, dest);
+		dest->sign = (unsigned char) sign;
+	}
+	EXCEPTION(EX_ZeroDiv);
+
+	return;
+
+}
+
+
+/* This may be called often, so keep it lean */
+void
+set_precision_flag_up(void)
+{
+	if (control_word & CW_Precision)
+		status_word |= (SW_Precision | SW_C1);	/* The masked response */
+	else
+		exception(EX_Precision | SW_C1);
+
+}
+
+
+/* This may be called often, so keep it lean */
+void
+set_precision_flag_down(void)
+{
+	if (control_word & CW_Precision) {	/* The masked response */
+		status_word &= ~SW_C1;
+		status_word |= SW_Precision;
+	} else
+		exception(EX_Precision);
+}
+
+
+int
+denormal_operand(void)
+{
+	if (control_word & CW_Denormal) {	/* The masked response */
+		status_word |= SW_Denorm_Op;
+		return 0;
+	} else {
+		exception(EX_Denormal);
+		return 1;
+	}
+}
+
+
+void
+arith_overflow(FPU_REG * dest)
+{
+
+	if (control_word & CW_Overflow) {
+		char    sign;
+		/* The masked response */
+/* **** The response here depends upon the rounding mode */
+		sign = dest->sign;
+		reg_move(&CONST_INF, dest);
+		dest->sign = sign;
+	} else {
+		/* Subtract the magic number from the exponent */
+		dest->exp -= (3 * (1 << 13));
+	}
+
+	/* By definition, precision is lost. It appears that the roundup bit
+	 * (C1) is also set by convention. */
+	EXCEPTION(EX_Overflow | EX_Precision | SW_C1);
+
+	return;
+
+}
+
+
+void
+arith_underflow(FPU_REG * dest)
+{
+
+	if (control_word & CW_Underflow) {
+		/* The masked response */
+		if (dest->exp <= EXP_UNDER - 63)
+			reg_move(&CONST_Z, dest);
+	} else {
+		/* Add the magic number to the exponent */
+		dest->exp += (3 * (1 << 13));
+	}
+
+	EXCEPTION(EX_Underflow);
+
+	return;
+}
+
+
+void
+stack_overflow(void)
+{
+
+	if (control_word & CW_Invalid) {
+		/* The masked response */
+		top--;
+		reg_move(&CONST_QNaN, FPU_st0_ptr = &st(0));
+	}
+	EXCEPTION(EX_StackOver);
+
+	return;
+
+}
+
+
+void
+stack_underflow(void)
+{
+
+	if (control_word & CW_Invalid) {
+		/* The masked response */
+		reg_move(&CONST_QNaN, FPU_st0_ptr);
+	}
+	EXCEPTION(EX_StackUnder);
+
+	return;
+
+}
+
+
+void
+stack_underflow_i(int i)
+{
+
+	if (control_word & CW_Invalid) {
+		/* The masked response */
+		reg_move(&CONST_QNaN, &(st(i)));
+	}
+	EXCEPTION(EX_StackUnder);
+
+	return;
+
+}
+
+
+void
+stack_underflow_pop(int i)
+{
+
+	if (control_word & CW_Invalid) {
+		/* The masked response */
+		reg_move(&CONST_QNaN, &(st(i)));
+		pop();
+	}
+	EXCEPTION(EX_StackUnder);
+
+	return;
+
+}
diff --git a/sys/gnu/i386/fpemul/exception.h b/sys/gnu/i386/fpemul/exception.h
new file mode 100644
index 0000000..c474eca
--- /dev/null
+++ b/sys/gnu/i386/fpemul/exception.h
@@ -0,0 +1,88 @@
+/*
+ *  exception.h
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _EXCEPTION_H_
+#define _EXCEPTION_H_
+
+
+#ifdef LOCORE
+#define	Const_(x)	$/**/x
+#else
+#define	Const_(x)	x
+#endif
+
+#ifndef SW_C1
+#include "fpu_emu.h"
+#endif				/* SW_C1 */
+
+#define FPU_BUSY        Const_(0x8000)	/* FPU busy bit (8087 compatibility) */
+#define EX_ErrorSummary Const_(0x0080)	/* Error summary status */
+/* Special exceptions: */
+#define	EX_INTERNAL	Const_(0x8000)	/* Internal error in wm-FPU-emu */
+#define EX_StackOver	Const_(0x0041|SW_C1)	/* stack overflow */
+#define EX_StackUnder	Const_(0x0041)	/* stack underflow */
+/* Exception flags: */
+#define EX_Precision	Const_(0x0020)	/* loss of precision */
+#define EX_Underflow	Const_(0x0010)	/* underflow */
+#define EX_Overflow	Const_(0x0008)	/* overflow */
+#define EX_ZeroDiv	Const_(0x0004)	/* divide by zero */
+#define EX_Denormal	Const_(0x0002)	/* denormalized operand */
+#define EX_Invalid	Const_(0x0001)	/* invalid operation */
+
+
+#ifndef LOCORE
+
+#ifdef DEBUG
+#define	EXCEPTION(x)	{ printf("exception in %s at line %d\n", \
+	__FILE__, __LINE__); exception(x); }
+#else
+#define	EXCEPTION(x)	exception(x)
+#endif
+
+#endif				/* LOCORE */
+
+#endif				/* _EXCEPTION_H_ */
diff --git a/sys/gnu/i386/fpemul/fpu_arith.c b/sys/gnu/i386/fpemul/fpu_arith.c
new file mode 100644
index 0000000..24dff5c
--- /dev/null
+++ b/sys/gnu/i386/fpemul/fpu_arith.c
@@ -0,0 +1,222 @@
+/*
+ *  fpu_arith.c
+ *
+ * Code to implement the FPU register/register arithmetic instructions
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+
+
+#include "param.h"
+#include "proc.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "control_w.h"
+
+
+void
+fadd__()
+{
+	/* fadd st,st(i) */
+	reg_add(FPU_st0_ptr, &st(FPU_rm), FPU_st0_ptr, control_word);
+}
+
+
+void
+fmul__()
+{
+	/* fmul st,st(i) */
+	reg_mul(FPU_st0_ptr, &st(FPU_rm), FPU_st0_ptr, control_word);
+}
+
+
+
+void
+fsub__()
+{
+	/* fsub st,st(i) */
+	reg_sub(FPU_st0_ptr, &st(FPU_rm), FPU_st0_ptr, control_word);
+}
+
+
+void
+fsubr_()
+{
+	/* fsubr st,st(i) */
+	reg_sub(&st(FPU_rm), FPU_st0_ptr, FPU_st0_ptr, control_word);
+}
+
+
+void
+fdiv__()
+{
+	/* fdiv st,st(i) */
+	reg_div(FPU_st0_ptr, &st(FPU_rm), FPU_st0_ptr, control_word);
+}
+
+
+void
+fdivr_()
+{
+	/* fdivr st,st(i) */
+	reg_div(&st(FPU_rm), FPU_st0_ptr, FPU_st0_ptr, control_word);
+}
+
+
+
+void
+fadd_i()
+{
+	/* fadd st(i),st */
+	reg_add(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm), control_word);
+}
+
+
+void
+fmul_i()
+{
+	/* fmul st(i),st */
+	reg_mul(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm), control_word);
+}
+
+
+void
+fsubri()
+{
+	/* fsubr st(i),st */
+	/* This is the sense of the 80486 manual reg_sub(&st(FPU_rm),
+	 * FPU_st0_ptr, &st(FPU_rm), control_word); */
+	reg_sub(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm), control_word);
+}
+
+
+void
+fsub_i()
+{
+	/* fsub st(i),st */
+	/* This is the sense of the 80486 manual reg_sub(FPU_st0_ptr,
+	 * &st(FPU_rm), &st(FPU_rm), control_word); */
+	reg_sub(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm), control_word);
+}
+
+
+void
+fdivri()
+{
+	/* fdivr st(i),st */
+	reg_div(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm), control_word);
+}
+
+
+void
+fdiv_i()
+{
+	/* fdiv st(i),st */
+	reg_div(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm), control_word);
+}
+
+
+
+void
+faddp_()
+{
+	/* faddp st(i),st */
+	reg_add(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm), control_word);
+	pop();
+}
+
+
+void
+fmulp_()
+{
+	/* fmulp st(i),st */
+	reg_mul(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm), control_word);
+	pop();
+}
+
+
+
+void
+fsubrp()
+{
+	/* fsubrp st(i),st */
+	/* This is the sense of the 80486 manual reg_sub(&st(FPU_rm),
+	 * FPU_st0_ptr, &st(FPU_rm), control_word); */
+	reg_sub(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm), control_word);
+	pop();
+}
+
+
+void
+fsubp_()
+{
+	/* fsubp st(i),st */
+	/* This is the sense of the 80486 manual reg_sub(FPU_st0_ptr,
+	 * &st(FPU_rm), &st(FPU_rm), control_word); */
+	reg_sub(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm), control_word);
+	pop();
+}
+
+
+void
+fdivrp()
+{
+	/* fdivrp st(i),st */
+	reg_div(FPU_st0_ptr, &st(FPU_rm), &st(FPU_rm), control_word);
+	pop();
+}
+
+
+void
+fdivp_()
+{
+	/* fdivp st(i),st */
+	reg_div(&st(FPU_rm), FPU_st0_ptr, &st(FPU_rm), control_word);
+	pop();
+}
diff --git a/sys/gnu/i386/fpemul/fpu_asm.h b/sys/gnu/i386/fpemul/fpu_asm.h
new file mode 100644
index 0000000..51df704
--- /dev/null
+++ b/sys/gnu/i386/fpemul/fpu_asm.h
@@ -0,0 +1,69 @@
+/*
+ *  fpu_asm.h
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _FPU_ASM_H_
+#define _FPU_ASM_H_
+
+#include "fpu_emu.h"
+
+#define	EXCEPTION	_exception
+
+
+#define PARAM1	8(%ebp)
+#define	PARAM2	12(%ebp)
+#define	PARAM3	16(%ebp)
+#define	PARAM4	20(%ebp)
+
+#define SIGL_OFFSET 8
+#define SIGN(x)	(x)
+#define	TAG(x)	1(x)
+#define	EXP(x)	4(x)
+#define SIG(x)	SIGL_OFFSET/**/(x)
+#define	SIGL(x)	SIGL_OFFSET/**/(x)
+#define	SIGH(x)	12(x)
+
+#endif				/* _FPU_ASM_H_ */
diff --git a/sys/gnu/i386/fpemul/fpu_aux.c b/sys/gnu/i386/fpemul/fpu_aux.c
new file mode 100644
index 0000000..652d384
--- /dev/null
+++ b/sys/gnu/i386/fpemul/fpu_aux.c
@@ -0,0 +1,220 @@
+/*
+ *  fpu_aux.c
+ *
+ * Code to implement some of the FPU auxiliary instructions.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include "param.h"
+#include "proc.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "exception.h"
+#include "status_w.h"
+
+
+
+void
+fclex(void)
+{
+	status_word &= ~(SW_Backward | SW_Summary | SW_Stack_Fault | SW_Precision |
+	    SW_Underflow | SW_Overflow | SW_Zero_Div | SW_Denorm_Op |
+	    SW_Invalid);
+	FPU_entry_eip = ip_offset;	/* We want no net effect */
+}
+/* Needs to be externally visible */
+void
+finit()
+{
+	int     r;
+	control_word = 0x037f;
+	status_word = 0;
+	top = 0;		/* We don't keep top in the status word
+				 * internally. */
+	for (r = 0; r < 8; r++) {
+		regs[r].tag = TW_Empty;
+	}
+	FPU_entry_eip = ip_offset = 0;
+}
+
+static FUNC finit_table[] = {
+	Un_impl, Un_impl, fclex, finit, Un_impl, Un_impl, Un_impl, Un_impl
+};
+
+void
+finit_()
+{
+	(finit_table[FPU_rm]) ();
+}
+
+
+static void
+fstsw_ax(void)
+{
+
+	status_word &= ~SW_Top;
+	status_word |= (top & 7) << SW_Top_Shift;
+
+	*(short *) &FPU_EAX = status_word;
+
+}
+
+static FUNC fstsw_table[] = {
+	fstsw_ax, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl
+};
+
+void
+fstsw_()
+{
+	(fstsw_table[FPU_rm]) ();
+}
+
+
+
+static void
+fnop(void)
+{
+}
+
+FUNC    fp_nop_table[] = {
+	fnop, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl, Un_impl
+};
+
+void
+fp_nop()
+{
+	(fp_nop_table[FPU_rm]) ();
+}
+
+
+void
+fld_i_()
+{
+	FPU_REG *st_new_ptr;
+
+	if (STACK_OVERFLOW) {
+		stack_overflow();
+		return;
+	}
+	/* fld st(i) */
+	if (NOT_EMPTY(FPU_rm)) {
+		reg_move(&st(FPU_rm), st_new_ptr);
+		push();
+	} else {
+		if (control_word & EX_Invalid) {
+			/* The masked response */
+			push();
+			stack_underflow();
+		} else
+			EXCEPTION(EX_StackUnder);
+	}
+
+}
+
+
+void
+fxch_i()
+{
+	/* fxch st(i) */
+	FPU_REG t;
+	register FPU_REG *sti_ptr = &st(FPU_rm);
+
+	if (FPU_st0_tag == TW_Empty) {
+		if (sti_ptr->tag == TW_Empty) {
+			stack_underflow();
+			stack_underflow_i(FPU_rm);
+			return;
+		}
+		reg_move(sti_ptr, FPU_st0_ptr);
+		stack_underflow_i(FPU_rm);
+		return;
+	}
+	if (sti_ptr->tag == TW_Empty) {
+		reg_move(FPU_st0_ptr, sti_ptr);
+		stack_underflow();
+		return;
+	}
+	reg_move(FPU_st0_ptr, &t);
+	reg_move(sti_ptr, FPU_st0_ptr);
+	reg_move(&t, sti_ptr);
+}
+
+
+void
+ffree_()
+{
+	/* ffree st(i) */
+	st(FPU_rm).tag = TW_Empty;
+}
+
+
+void
+ffreep()
+{
+	/* ffree st(i) + pop - unofficial code */
+	st(FPU_rm).tag = TW_Empty;
+	pop();
+}
+
+
+void
+fst_i_()
+{
+	/* fst st(i) */
+	reg_move(FPU_st0_ptr, &st(FPU_rm));
+}
+
+
+void
+fstp_i()
+{
+	/* fstp st(i) */
+	reg_move(FPU_st0_ptr, &st(FPU_rm));
+	pop();
+}
diff --git a/sys/gnu/i386/fpemul/fpu_emu.h b/sys/gnu/i386/fpemul/fpu_emu.h
new file mode 100644
index 0000000..6bab229
--- /dev/null
+++ b/sys/gnu/i386/fpemul/fpu_emu.h
@@ -0,0 +1,175 @@
+/*
+ *  fpu_emu.h
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#ifndef _FPU_EMU_H_
+#define _FPU_EMU_H_
+
+/*
+ * Define DENORM_OPERAND to make the emulator detect denormals
+ * and use the denormal flag of the status word. Note: this only
+ * affects the flag and corresponding interrupt, the emulator
+ * will always generate denormals and operate upon them as required.
+ */
+#define DENORM_OPERAND
+
+/*
+ * Define PECULIAR_486 to get a closer approximation to 80486 behaviour,
+ * rather than behaviour which appears to be cleaner.
+ * This is a matter of opinion: for all I know, the 80486 may simply
+ * be complying with the IEEE spec. Maybe one day I'll get to see the
+ * spec...
+ */
+#define PECULIAR_486
+
+#ifdef LOCORE
+#include "fpu_asm.h"
+#define	Const(x)	$/**/x
+#else
+#define	Const(x)	x
+#endif
+
+#define EXP_BIAS	Const(0)
+#define EXP_OVER	Const(0x4000)	/* smallest invalid large exponent */
+#define	EXP_UNDER	Const(-0x3fff)	/* largest invalid small exponent */
+
+#define SIGN_POS	Const(0)
+#define SIGN_NEG	Const(1)
+
+/* Keep the order TW_Valid, TW_Zero, TW_Denormal */
+#define TW_Valid	Const(0)/* valid */
+#define TW_Zero		Const(1)/* zero */
+/* The following fold to 2 (Special) in the Tag Word */
+#define TW_Denormal     Const(4)/* De-normal */
+#define TW_Infinity	Const(5)/* + or - infinity */
+#define	TW_NaN		Const(6)/* Not a Number */
+
+#define TW_Empty	Const(7)/* empty */
+
+ /* #define TW_FPU_Interrupt Const(0x80) *//* Signals an interrupt */
+
+
+#ifndef LOCORE
+
+#include "types.h"
+#include "math_emu.h"
+
+#ifdef PARANOID
+extern char emulating;
+#define REENTRANT_CHECK(state) emulating = (state)
+#define ON 1
+#define OFF 0
+#else
+#define REENTRANT_CHECK(state)
+#endif				/* PARANOID */
+
+typedef void (*FUNC) (void);
+typedef struct fpu_reg FPU_REG;
+
+#define	st(x)	( regs[((top+x) &7 )] )
+
+#define	STACK_OVERFLOW	(st_new_ptr = &st(-1), st_new_ptr->tag != TW_Empty)
+#define	NOT_EMPTY(i)	(st(i).tag != TW_Empty)
+#define	NOT_EMPTY_0	(FPU_st0_tag ^ TW_Empty)
+
+extern unsigned char FPU_rm;
+
+extern char FPU_st0_tag;
+extern FPU_REG *FPU_st0_ptr;
+
+extern void *FPU_data_address;
+
+extern FPU_REG FPU_loaded_data;
+
+#define pop()	{ FPU_st0_ptr->tag = TW_Empty; top++; }
+
+/* push() does not affect the tags */
+#define push()	{ top--; FPU_st0_ptr = st_new_ptr; }
+
+
+#define reg_move(x, y) { \
+		 *(short *)&((y)->sign) = *(short *)&((x)->sign); \
+		 *(long *)&((y)->exp) = *(long *)&((x)->exp); \
+		 *(long long *)&((y)->sigl) = *(long long *)&((x)->sigl); }
+
+
+/*----- Prototypes for functions written in assembler -----*/
+/* extern void reg_move(FPU_REG *a, FPU_REG *b); */
+
+extern void mul64(long long *a, long long *b, long long *result);
+extern void poly_div2(long long *x);
+extern void poly_div4(long long *x);
+extern void poly_div16(long long *x);
+extern void
+polynomial(unsigned accum[], unsigned x[],
+    unsigned short terms[][4], int n);
+	extern void normalize(FPU_REG * x);
+	extern void normalize_nuo(FPU_REG * x);
+	extern void reg_div(FPU_REG * arg1, FPU_REG * arg2, FPU_REG * answ,
+            unsigned int control_w);
+	extern void reg_u_sub(FPU_REG * arg1, FPU_REG * arg2, FPU_REG * answ,
+            unsigned int control_w);
+	extern void reg_u_mul(FPU_REG * arg1, FPU_REG * arg2, FPU_REG * answ,
+            unsigned int control_w);
+	extern void reg_u_div(FPU_REG * arg1, FPU_REG * arg2, FPU_REG * answ,
+            unsigned int control_w);
+	extern void reg_u_add(FPU_REG * arg1, FPU_REG * arg2, FPU_REG * answ,
+            unsigned int control_w);
+	extern void wm_sqrt(FPU_REG * n, unsigned int control_w);
+	extern unsigned shrx(void *l, unsigned x);
+	extern unsigned shrxs(void *v, unsigned x);
+	extern unsigned long div_small(unsigned long long *x, unsigned long y);
+	extern void round_reg(FPU_REG * arg, unsigned int extent,
+            unsigned int control_w);
+
+#ifndef MAKING_PROTO
+#include "fpu_proto.h"
+#endif
+
+#endif				/* LOCORE */
+
+#endif				/* _FPU_EMU_H_ */
diff --git a/sys/gnu/i386/fpemul/fpu_entry.c b/sys/gnu/i386/fpemul/fpu_entry.c
new file mode 100644
index 0000000..e1b59e4
--- /dev/null
+++ b/sys/gnu/i386/fpemul/fpu_entry.c
@@ -0,0 +1,500 @@
+/*
+ *  fpu_entry.c
+ *
+ * The entry function for wm-FPU-emu
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * The purpose of the copyright is to ensure that the covered software
+ * remains freely available to everyone. It is felt to be necessary to
+ * try and prevent the software being taken by unscrupulous people and
+ * (perhaps after modification) being copyrighted or otherwise
+ * restricted and being made no longer freely available. There are a
+ * number of examples of corporations hijacking ideas and trying to
+ * sue the pants of lesser financed entities who try to subsequently
+ * use the ideas.
+ *
+ * If the software were placed in the public domain then there would
+ * be no protection at all. By claiming a copyright it puts at least a
+ * strong moral pressure on the greedy to restrain themselves and
+ * behave ethically. And let's not be naive, we are all subject to the
+ * emotion of greed to some extent...
+ *
+ * Up until now, the software has been covered by the GNU copyleft.
+ * That copyright mechanism has problems for operating systems which
+ * are not themselves covered by the GNU copyleft. Hence I have
+ * decided to allow the covered software to be used with 386BSD under
+ * restrictions which are meant to be broadly similar, but not
+ * identical, to those which already cover the 386BSD operating
+ * system.
+ *
+ * The software, in its form for the Linux operating system, remains
+ * available under the terms of the GNU copyleft.
+ *
+ * W. Metzenthen   June 1993.
+ */
+
+/*---------------------------------------------------------------------------+
+ | Note:                                                                     |
+ |    The file contains code which accesses user memory.                     |
+ |    Emulator static data may change when user memory is accessed, due to   |
+ |    other processes using the emulator while swapping is in progress.      |
+ +---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------+
+ | math_emulate() is the sole entry point for wm-FPU-emu                     |
+ +---------------------------------------------------------------------------*/
+
+
+#include "param.h"
+#include "systm.h"
+#include "proc.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "exception.h"
+#include "control_w.h"
+#include "status_w.h"
+
+
+#define __BAD__ Un_impl		/* Not implemented */
+
+#define FPU_LOOKAHEAD   1       /* For performance boost */
+
+#if FPU_LOOKAHEAD != 0          /* I think thet we have to limit the */
+#define LOOKAHEAD_LIMIT	7	/* Max number of lookahead instructions*/
+#endif                          /* Or else a prog consisting of a million */
+                                /* fnops will spend all its time in kernel*/
+
+#ifndef NO_UNDOC_CODE		/* Un-documented FPU op-codes supported by
+				 * default. */
+
+/* WARNING: These codes are not documented by Intel in their 80486 manual
+   and may not work on FPU clones or later Intel FPUs. */
+
+/* Changes to support the un-doc codes provided by Linus Torvalds. */
+
+#define _d9_d8_ fstp_i		/* unofficial code (19) */
+#define _dc_d0_ fcom_st		/* unofficial code (14) */
+#define _dc_d8_ fcompst		/* unofficial code (1c) */
+#define _dd_c8_ fxch_i		/* unofficial code (0d) */
+#define _de_d0_ fcompst		/* unofficial code (16) */
+#define _df_c0_ ffreep		/* unofficial code (07) ffree + pop */
+#define _df_c8_ fxch_i		/* unofficial code (0f) */
+#define _df_d0_ fstp_i		/* unofficial code (17) */
+#define _df_d8_ fstp_i		/* unofficial code (1f) */
+
+static FUNC st_instr_table[64] = {
+	fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, _df_c0_,
+	fmul__, fxch_i, __BAD__, __BAD__, fmul_i, _dd_c8_, fmulp_, _df_c8_,
+	fcom_st, fp_nop, __BAD__, __BAD__, _dc_d0_, fst_i_, _de_d0_, _df_d0_,
+	fcompst, _d9_d8_, __BAD__, __BAD__, _dc_d8_, fstp_i, fcompp, _df_d8_,
+	fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
+	fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
+	fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
+	fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
+};
+#else				/* Support only documented FPU op-codes */
+
+static FUNC st_instr_table[64] = {
+	fadd__, fld_i_, __BAD__, __BAD__, fadd_i, ffree_, faddp_, __BAD__,
+	fmul__, fxch_i, __BAD__, __BAD__, fmul_i, __BAD__, fmulp_, __BAD__,
+	fcom_st, fp_nop, __BAD__, __BAD__, __BAD__, fst_i_, __BAD__, __BAD__,
+	fcompst, __BAD__, __BAD__, __BAD__, __BAD__, fstp_i, fcompp, __BAD__,
+	fsub__, fp_etc, __BAD__, finit_, fsubri, fucom_, fsubrp, fstsw_,
+	fsubr_, fconst, fucompp, __BAD__, fsub_i, fucomp, fsubp_, __BAD__,
+	fdiv__, trig_a, __BAD__, __BAD__, fdivri, __BAD__, fdivrp, __BAD__,
+	fdivr_, trig_b, __BAD__, __BAD__, fdiv_i, __BAD__, fdivp_, __BAD__,
+};
+#endif				/* NO_UNDOC_CODE */
+
+
+#define _NONE_ 0		/* Take no special action */
+#define _REG0_ 1		/* Need to check for not empty st(0) */
+#define _REGI_ 2		/* Need to check for not empty st(0) and
+				 * st(rm) */
+#define _REGi_ 0		/* Uses st(rm) */
+#define _PUSH_ 3		/* Need to check for space to push onto stack */
+#define _null_ 4		/* Function illegal or not implemented */
+#define _REGIi 5		/* Uses st(0) and st(rm), result to st(rm) */
+#define _REGIp 6		/* Uses st(0) and st(rm), result to st(rm)
+				 * then pop */
+#define _REGIc 0		/* Compare st(0) and st(rm) */
+#define _REGIn 0		/* Uses st(0) and st(rm), but handle checks
+				 * later */
+
+#ifndef NO_UNDOC_CODE
+
+/* Un-documented FPU op-codes supported by default. (see above) */
+
+static unsigned char type_table[64] = {
+	_REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _REGi_,
+	_REGI_, _REGIn, _null_, _null_, _REGIi, _REGI_, _REGIp, _REGI_,
+	_REGIc, _NONE_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
+	_REGIc, _REG0_, _null_, _null_, _REGIc, _REG0_, _REGIc, _REG0_,
+	_REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
+	_REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
+	_REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
+	_REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
+};
+#else				/* Support only documented FPU op-codes */
+
+static unsigned char type_table[64] = {
+	_REGI_, _NONE_, _null_, _null_, _REGIi, _REGi_, _REGIp, _null_,
+	_REGI_, _REGIn, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
+	_REGIc, _NONE_, _null_, _null_, _null_, _REG0_, _null_, _null_,
+	_REGIc, _null_, _null_, _null_, _null_, _REG0_, _REGIc, _null_,
+	_REGI_, _NONE_, _null_, _NONE_, _REGIi, _REGIc, _REGIp, _NONE_,
+	_REGI_, _NONE_, _REGIc, _null_, _REGIi, _REGIc, _REGIp, _null_,
+	_REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_,
+	_REGI_, _NONE_, _null_, _null_, _REGIi, _null_, _REGIp, _null_
+};
+#endif				/* NO_UNDOC_CODE */
+
+/* Be careful when using any of these global variables...
+   they might change if swapping is triggered */
+unsigned char FPU_rm;
+char    FPU_st0_tag;
+FPU_REG *FPU_st0_ptr;
+
+#ifdef PARANOID
+char    emulating = 0;
+#endif				/* PARANOID */
+
+#define bswapw(x) __asm__("xchgb %%al,%%ah":"=a" (x):"0" ((short)x))
+#define math_abort(signo) \
+    FPU_EIP = FPU_ORIG_EIP;REENTRANT_CHECK(OFF);return(signo);
+
+int
+math_emulate(struct trapframe * tframe)
+{
+
+	unsigned char FPU_modrm;
+	unsigned short code;
+#ifdef LOOKAHEAD_LIMIT
+	int lookahead_limit = LOOKAHEAD_LIMIT;
+#endif
+#ifdef PARANOID
+	if (emulating) {
+		printf("ERROR: wm-FPU-emu is not RE-ENTRANT!\n");
+	}
+	REENTRANT_CHECK(ON);
+#endif				/* PARANOID */
+
+	if ((((struct pcb *) curproc->p_addr)->pcb_flags & FP_SOFTFP) == 0) {
+		finit();
+		((struct pcb *) curproc->p_addr)->pcb_flags |= FP_SOFTFP;
+	}
+	FPU_info = tframe;
+	FPU_ORIG_EIP = FPU_EIP;	/* --pink-- */
+
+	if (FPU_CS != 0x001f) {
+		printf("math_emulate: %x : %x\n", FPU_CS, FPU_EIP);
+		panic("FPU emulation in kernel");
+	}
+#ifdef notyet
+	/* We cannot handle emulation in v86-mode */
+	if (FPU_EFLAGS & 0x00020000) {
+		FPU_ORIG_EIP = FPU_EIP;
+		math_abort(FPU_info, SIGILL);
+	}
+#endif
+
+	FPU_lookahead = FPU_LOOKAHEAD;
+#if notnow /* I dont know that much of traceing. Is it right? --pink-- */
+	if (curproc->p_flag & STRC)
+		FPU_lookahead = 0;
+#endif
+
+do_another_FPU_instruction:
+
+	REENTRANT_CHECK(OFF);
+	code = fuword((u_int *) FPU_EIP);
+	REENTRANT_CHECK(ON);
+	if ((code & 0xff) == 0x9b) {	/* fwait */
+		if (status_word & SW_Summary)
+			goto do_the_FPU_interrupt;
+		else {
+			FPU_EIP++;
+			goto FPU_instruction_done;
+		}
+	}
+	if (status_word & SW_Summary) {
+		/* Ignore the error for now if the current instruction is a
+		 * no-wait control instruction */
+		/* The 80486 manual contradicts itself on this topic, so I use
+		 * the following list of such instructions until I can check
+		 * on a real 80486: fninit, fnstenv, fnsave, fnstsw, fnstenv,
+		 * fnclex. */
+		if (!((((code & 0xf803) == 0xe003) ||	/* fnclex, fninit,
+							 * fnstsw */
+			    (((code & 0x3003) == 0x3001) &&	/* fnsave, fnstcw,
+								 * fnstenv, fnstsw */
+				((code & 0xc000) != 0xc000))))) {
+			/* This is a guess about what a real FPU might do to
+			 * this bit: */
+/*	  status_word &= ~SW_Summary; ****/
+
+			/* We need to simulate the action of the kernel to FPU
+			 * interrupts here. Currently, the "real FPU" part of
+			 * the kernel (0.99.10) clears the exception flags,
+			 * sets the registers to empty, and passes information
+			 * back to the interrupted process via the cs selector
+			 * and operand selector, so we do the same. */
+	do_the_FPU_interrupt:
+			cs_selector &= 0xffff0000;
+			cs_selector |= (status_word & ~SW_Top) | ((top & 7) << SW_Top_Shift);
+			operand_selector = tag_word();
+			status_word = 0;
+			top = 0;
+			{
+				int     r;
+				for (r = 0; r < 8; r++) {
+					regs[r].tag = TW_Empty;
+				}
+			}
+			REENTRANT_CHECK(OFF);
+			math_abort(SIGFPE);
+		}
+	}
+	FPU_entry_eip = FPU_ORIG_EIP = FPU_EIP;
+
+	if ((code & 0xff) == 0x66) {	/* size prefix */
+		FPU_EIP++;
+		REENTRANT_CHECK(OFF);
+		code = fuword((u_int *) FPU_EIP);
+		REENTRANT_CHECK(ON);
+	}
+	FPU_EIP += 2;
+
+	FPU_modrm = code >> 8;
+	FPU_rm = FPU_modrm & 7;
+
+	if (FPU_modrm < 0300) {
+		/* All of these instructions use the mod/rm byte to get a data
+		 * address */
+		get_address(FPU_modrm);
+		if (!(code & 1)) {
+			unsigned short status1 = status_word;
+			FPU_st0_ptr = &st(0);
+			FPU_st0_tag = FPU_st0_ptr->tag;
+
+			/* Stack underflow has priority */
+			if (NOT_EMPTY_0) {
+				switch ((code >> 1) & 3) {
+				case 0:
+					reg_load_single();
+					break;
+				case 1:
+					reg_load_int32();
+					break;
+				case 2:
+					reg_load_double();
+					break;
+				case 3:
+					reg_load_int16();
+					break;
+				}
+
+				/* No more access to user memory, it is safe
+				 * to use static data now */
+				FPU_st0_ptr = &st(0);
+				FPU_st0_tag = FPU_st0_ptr->tag;
+
+				/* NaN operands have the next priority. */
+				/* We have to delay looking at st(0) until
+				 * after loading the data, because that data
+				 * might contain an SNaN */
+				if ((FPU_st0_tag == TW_NaN) ||
+				    (FPU_loaded_data.tag == TW_NaN)) {
+					/* Restore the status word; we might
+					 * have loaded a denormal. */
+					status_word = status1;
+					if ((FPU_modrm & 0x30) == 0x10) {
+						/* fcom or fcomp */
+						EXCEPTION(EX_Invalid);
+						setcc(SW_C3 | SW_C2 | SW_C0);
+						if (FPU_modrm & 0x08)
+							pop();	/* fcomp, so we pop. */
+					} else
+						real_2op_NaN(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr);
+					goto reg_mem_instr_done;
+				}
+				switch ((FPU_modrm >> 3) & 7) {
+				case 0:	/* fadd */
+					reg_add(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
+					break;
+				case 1:	/* fmul */
+					reg_mul(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
+					break;
+				case 2:	/* fcom */
+					compare_st_data();
+					break;
+				case 3:	/* fcomp */
+					compare_st_data();
+					pop();
+					break;
+				case 4:	/* fsub */
+					reg_sub(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
+					break;
+				case 5:	/* fsubr */
+					reg_sub(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr, control_word);
+					break;
+				case 6:	/* fdiv */
+					reg_div(FPU_st0_ptr, &FPU_loaded_data, FPU_st0_ptr, control_word);
+					break;
+				case 7:	/* fdivr */
+					if (FPU_st0_tag == TW_Zero)
+						status_word = status1;	/* Undo any denorm tag,
+									 * zero-divide has
+									 * priority. */
+					reg_div(&FPU_loaded_data, FPU_st0_ptr, FPU_st0_ptr, control_word);
+					break;
+				}
+			} else {
+				if ((FPU_modrm & 0x30) == 0x10) {
+					/* The instruction is fcom or fcomp */
+					EXCEPTION(EX_StackUnder);
+					setcc(SW_C3 | SW_C2 | SW_C0);
+					if (FPU_modrm & 0x08)
+						pop();	/* fcomp, Empty or not,
+							 * we pop. */
+				} else
+					stack_underflow();
+			}
+		} else {
+			load_store_instr(((FPU_modrm & 0x38) | (code & 6)) >> 1);
+		}
+
+reg_mem_instr_done:
+
+		data_operand_offset = (unsigned long) FPU_data_address;
+	} else {
+		/* None of these instructions access user memory */
+		unsigned char instr_index = (FPU_modrm & 0x38) | (code & 7);
+
+		FPU_st0_ptr = &st(0);
+		FPU_st0_tag = FPU_st0_ptr->tag;
+		switch (type_table[(int) instr_index]) {
+		case _NONE_:	/* also _REGIc: _REGIn */
+			break;
+		case _REG0_:
+			if (!NOT_EMPTY_0) {
+				stack_underflow();
+				goto FPU_instruction_done;
+			}
+			break;
+		case _REGIi:
+			if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
+				stack_underflow_i(FPU_rm);
+				goto FPU_instruction_done;
+			}
+			break;
+		case _REGIp:
+			if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
+				stack_underflow_i(FPU_rm);
+				pop();
+				goto FPU_instruction_done;
+			}
+			break;
+		case _REGI_:
+			if (!NOT_EMPTY_0 || !NOT_EMPTY(FPU_rm)) {
+				stack_underflow();
+				goto FPU_instruction_done;
+			}
+			break;
+		case _PUSH_:	/* Only used by the fld st(i) instruction */
+			break;
+		case _null_:
+			Un_impl();
+			goto FPU_instruction_done;
+		default:
+			EXCEPTION(EX_INTERNAL | 0x111);
+			goto FPU_instruction_done;
+		}
+		(*st_instr_table[(int) instr_index]) ();
+	}
+
+FPU_instruction_done:
+
+	ip_offset = FPU_entry_eip;
+	bswapw(code);
+	*(1 + (unsigned short *) &cs_selector) = code & 0x7ff;
+
+#ifdef DEBUG
+	REENTRANT_CHECK(OFF);
+	emu_printall();
+	REENTRANT_CHECK(ON);
+#endif				/* DEBUG */
+#ifdef LOOKAHEAD_LIMIT
+if (--lookahead_limit)
+#endif
+	if (FPU_lookahead) {
+		unsigned char next;
+
+		/* (This test should generate no machine code) */
+		while (1) {
+			REENTRANT_CHECK(OFF);
+			next = fubyte((u_char *) FPU_EIP);
+			REENTRANT_CHECK(ON);
+			if (((next & 0xf8) == 0xd8) || (next == 0x9b)) {	/* fwait */
+				goto do_another_FPU_instruction;
+			} else
+				if (next == 0x66) {	/* size prefix */
+					REENTRANT_CHECK(OFF);
+					next = fubyte((u_char *) (FPU_EIP + 1));
+					REENTRANT_CHECK(ON);
+					if ((next & 0xf8) == 0xd8) {
+						FPU_EIP++;
+						goto do_another_FPU_instruction;
+					}
+				}
+			break;
+		}
+	}
+	REENTRANT_CHECK(OFF);
+	return (0);		/* --pink-- */
+}
diff --git a/sys/gnu/i386/fpemul/fpu_etc.c b/sys/gnu/i386/fpemul/fpu_etc.c
new file mode 100644
index 0000000..72f4526
--- /dev/null
+++ b/sys/gnu/i386/fpemul/fpu_etc.c
@@ -0,0 +1,162 @@
+/*
+ *  fpu_etc.c
+ *
+ * Implement a few FPU instructions.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "param.h"
+#include "proc.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "exception.h"
+#include "status_w.h"
+#include "reg_constant.h"
+
+
+static void
+fchs(void)
+{
+	if (NOT_EMPTY_0) {
+		FPU_st0_ptr->sign ^= SIGN_POS ^ SIGN_NEG;
+		status_word &= ~SW_C1;
+	} else
+		stack_underflow();
+}
+
+static void
+fabs(void)
+{
+	if (FPU_st0_tag ^ TW_Empty) {
+		FPU_st0_ptr->sign = SIGN_POS;
+		status_word &= ~SW_C1;
+	} else
+		stack_underflow();
+}
+
+
+static void
+ftst_(void)
+{
+	switch (FPU_st0_tag) {
+		case TW_Zero:
+		setcc(SW_C3);
+		break;
+	case TW_Valid:
+
+#ifdef DENORM_OPERAND
+		if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		if (FPU_st0_ptr->sign == SIGN_POS)
+			setcc(0);
+		else
+			setcc(SW_C0);
+		break;
+	case TW_NaN:
+		setcc(SW_C0 | SW_C2 | SW_C3);	/* Operand is not comparable */
+		EXCEPTION(EX_Invalid);
+		break;
+	case TW_Infinity:
+		if (FPU_st0_ptr->sign == SIGN_POS)
+			setcc(0);
+		else
+			setcc(SW_C0);
+		EXCEPTION(EX_Invalid);
+		break;
+	case TW_Empty:
+		setcc(SW_C0 | SW_C2 | SW_C3);
+		EXCEPTION(EX_StackUnder);
+		break;
+	default:
+		setcc(SW_C0 | SW_C2 | SW_C3);	/* Operand is not comparable */
+		EXCEPTION(EX_INTERNAL | 0x14);
+		break;
+	}
+}
+
+static void
+fxam(void)
+{
+	int     c = 0;
+	switch (FPU_st0_tag) {
+	case TW_Empty:
+		c = SW_C3 | SW_C0;
+		break;
+	case TW_Zero:
+		c = SW_C3;
+		break;
+	case TW_Valid:
+		/* This will need to be changed if TW_Denormal is ever used. */
+		if (FPU_st0_ptr->exp <= EXP_UNDER)
+			c = SW_C2 | SW_C3;	/* Denormal */
+		else
+			c = SW_C3;
+		break;
+	case TW_NaN:
+		c = SW_C0;
+		break;
+	case TW_Infinity:
+		c = SW_C2 | SW_C0;
+		break;
+	}
+	if (FPU_st0_ptr->sign == SIGN_NEG)
+		c |= SW_C1;
+	setcc(c);
+}
+
+static FUNC fp_etc_table[] = {
+	fchs, fabs, Un_impl, Un_impl, ftst_, fxam, Un_impl, Un_impl
+};
+
+void
+fp_etc()
+{
+	(fp_etc_table[FPU_rm]) ();
+}
diff --git a/sys/gnu/i386/fpemul/fpu_proto.h b/sys/gnu/i386/fpemul/fpu_proto.h
new file mode 100644
index 0000000..8ce7ed4
--- /dev/null
+++ b/sys/gnu/i386/fpemul/fpu_proto.h
@@ -0,0 +1,108 @@
+/* errors.c */
+extern void Un_impl(void);
+extern void emu_printall(void);
+extern void exception(int n);
+extern void real_2op_NaN(FPU_REG * a, FPU_REG * b, FPU_REG * dest);
+extern void arith_invalid(FPU_REG * dest);
+extern void divide_by_zero(int sign, FPU_REG * dest);
+extern void set_precision_flag_up(void);
+extern void set_precision_flag_down(void);
+extern int denormal_operand(void);
+extern void arith_overflow(FPU_REG * dest);
+extern void arith_underflow(FPU_REG * dest);
+extern void stack_overflow(void);
+extern void stack_underflow(void);
+extern void stack_underflow_i(int i);
+extern void stack_underflow_pop(int i);
+/* fpu_arith.c */
+extern void fadd__(void);
+extern void fmul__(void);
+extern void fsub__(void);
+extern void fsubr_(void);
+extern void fdiv__(void);
+extern void fdivr_(void);
+extern void fadd_i(void);
+extern void fmul_i(void);
+extern void fsubri(void);
+extern void fsub_i(void);
+extern void fdivri(void);
+extern void fdiv_i(void);
+extern void faddp_(void);
+extern void fmulp_(void);
+extern void fsubrp(void);
+extern void fsubp_(void);
+extern void fdivrp(void);
+extern void fdivp_(void);
+/* fpu_aux.c */
+extern void fclex(void);
+extern void finit(void);
+extern void finit_(void);
+extern void fstsw_(void);
+extern void fp_nop(void);
+extern void fld_i_(void);
+extern void fxch_i(void);
+extern void ffree_(void);
+extern void ffreep(void);
+extern void fst_i_(void);
+extern void fstp_i(void);
+/* fpu_entry.c */
+extern int math_emulate(struct trapframe * info);
+/* fpu_etc.c */
+extern void fp_etc(void);
+/* fpu_trig.c */
+extern void convert_l2reg(long *arg, FPU_REG * dest);
+extern void trig_a(void);
+extern void trig_b(void);
+/* get_address.c */
+extern void get_address(unsigned char FPU_modrm);
+/* load_store.c */
+extern void load_store_instr(char type);
+/* poly_2xm1.c */
+extern int poly_2xm1(FPU_REG * arg, FPU_REG * result);
+/* poly_atan.c */
+extern void poly_atan(FPU_REG * arg);
+extern void poly_add_1(FPU_REG * src);
+/* poly_l2.c */
+extern void poly_l2(FPU_REG * arg, FPU_REG * result);
+extern int poly_l2p1(FPU_REG * arg, FPU_REG * result);
+/* poly_sin.c */
+extern void poly_sine(FPU_REG * arg, FPU_REG * result);
+/* poly_tan.c */
+extern void poly_tan(FPU_REG * arg, FPU_REG * y_reg);
+/* reg_add_sub.c */
+extern void reg_add(FPU_REG * a, FPU_REG * b, FPU_REG * dest, int control_w);
+extern void reg_sub(FPU_REG * a, FPU_REG * b, FPU_REG * dest, int control_w);
+/* reg_compare.c */
+extern int compare(FPU_REG * b);
+extern int compare_st_data(void);
+extern void fcom_st(void);
+extern void fcompst(void);
+extern void fcompp(void);
+extern void fucom_(void);
+extern void fucomp(void);
+extern void fucompp(void);
+/* reg_constant.c */
+extern void fconst(void);
+/* reg_ld_str.c */
+extern void reg_load_extended(void);
+extern void reg_load_double(void);
+extern void reg_load_single(void);
+extern void reg_load_int64(void);
+extern void reg_load_int32(void);
+extern void reg_load_int16(void);
+extern void reg_load_bcd(void);
+extern int reg_store_extended(void);
+extern int reg_store_double(void);
+extern int reg_store_single(void);
+extern int reg_store_int64(void);
+extern int reg_store_int32(void);
+extern int reg_store_int16(void);
+extern int reg_store_bcd(void);
+extern int round_to_int(FPU_REG * r);
+extern char *fldenv(void);
+extern void frstor(void);
+extern unsigned short tag_word(void);
+extern char *fstenv(void);
+extern void fsave(void);
+/* reg_mul.c */
+extern void reg_mul(FPU_REG * a, FPU_REG * b, FPU_REG * dest, unsigned int control_w);
diff --git a/sys/gnu/i386/fpemul/fpu_system.h b/sys/gnu/i386/fpemul/fpu_system.h
new file mode 100644
index 0000000..e0488e9
--- /dev/null
+++ b/sys/gnu/i386/fpemul/fpu_system.h
@@ -0,0 +1,84 @@
+/*
+ *  fpu_system.h
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#ifndef _FPU_SYSTEM_H
+#define _FPU_SYSTEM_H
+
+/* system dependent definitions */
+
+/*
+#include <linux/sched.h>
+#include <linux/kernel.h>
+*/
+
+#define I387 (*(union i387_union *)&(((struct pcb *)curproc->p_addr)->pcb_savefpu))
+#define FPU_info		(I387.soft.frame)
+
+#define FPU_CS			(*(unsigned short *) &(FPU_info->tf_cs))
+#define FPU_DS			(*(unsigned short *) &(FPU_info->tf_ds))
+#define FPU_EAX			(FPU_info->tf_eax)
+#define FPU_EFLAGS		(FPU_info->tf_eflags)
+#define FPU_EIP			(FPU_info->tf_eip)
+/*#define FPU_ORIG_EIP		(FPU_info->___orig_eip) */
+/*#define FPU_ORIG_EIP		(FPU_info->tf_isp)*/
+#define FPU_ORIG_EIP		(I387.soft.orig_eip)
+
+#define FPU_lookahead           (I387.soft.lookahead)
+#define FPU_entry_eip           (I387.soft.entry_eip)
+
+#define status_word		(I387.soft.swd)
+#define control_word		(I387.soft.cwd)
+#define regs			(I387.soft.regs)
+#define top			(I387.soft.top)
+
+#define ip_offset		(I387.soft.fip)
+#define cs_selector		(I387.soft.fcs)
+#define data_operand_offset	(I387.soft.foo)
+#define operand_selector	(I387.soft.fos)
+
+#endif
diff --git a/sys/gnu/i386/fpemul/fpu_trig.c b/sys/gnu/i386/fpemul/fpu_trig.c
new file mode 100644
index 0000000..b83f615
--- /dev/null
+++ b/sys/gnu/i386/fpemul/fpu_trig.c
@@ -0,0 +1,1354 @@
+/*
+ *  fpu_trig.c
+ *
+ * Implementation of the FPU "transcendental" functions.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include "param.h"
+#include "proc.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "exception.h"
+#include "status_w.h"
+#include "reg_constant.h"
+#include "control_w.h"
+
+static int
+trig_arg(FPU_REG * X)
+{
+	FPU_REG tmp, quot;
+	int     rv;
+	long long q;
+	int     old_cw = control_word;
+
+	control_word &= ~CW_RC;
+	control_word |= RC_CHOP;
+
+	reg_move(X, &quot);
+	reg_div(&quot, &CONST_PI2, &quot, FULL_PRECISION);
+
+	reg_move(&quot, &tmp);
+	round_to_int(&tmp);
+	if (tmp.sigh & 0x80000000)
+		return -1;	/* |Arg| is >= 2^63 */
+	tmp.exp = EXP_BIAS + 63;
+	q = *(long long *) &(tmp.sigl);
+	normalize(&tmp);
+
+	reg_sub(&quot, &tmp, X, FULL_PRECISION);
+	rv = q & 7;
+
+	control_word = old_cw;
+	return rv;;
+}
+
+
+/* Convert a long to register */
+void
+convert_l2reg(long *arg, FPU_REG * dest)
+{
+	long    num = *arg;
+
+	if (num == 0) {
+		reg_move(&CONST_Z, dest);
+		return;
+	}
+	if (num > 0)
+		dest->sign = SIGN_POS;
+	else {
+		num = -num;
+		dest->sign = SIGN_NEG;
+	}
+
+	dest->sigh = num;
+	dest->sigl = 0;
+	dest->exp = EXP_BIAS + 31;
+	dest->tag = TW_Valid;
+	normalize(dest);
+}
+
+
+static void
+single_arg_error(void)
+{
+	switch (FPU_st0_tag) {
+		case TW_NaN:
+		if (!(FPU_st0_ptr->sigh & 0x40000000)) {	/* Signaling ? */
+			EXCEPTION(EX_Invalid);
+			/* Convert to a QNaN */
+			FPU_st0_ptr->sigh |= 0x40000000;
+		}
+		break;		/* return with a NaN in st(0) */
+	case TW_Empty:
+		stack_underflow();	/* Puts a QNaN in st(0) */
+		break;
+#ifdef PARANOID
+	default:
+		EXCEPTION(EX_INTERNAL | 0x0112);
+#endif				/* PARANOID */
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static void
+f2xm1(void)
+{
+	switch (FPU_st0_tag) {
+		case TW_Valid:
+		{
+			FPU_REG rv, tmp;
+
+#ifdef DENORM_OPERAND
+			if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+				return;
+#endif				/* DENORM_OPERAND */
+
+			if (FPU_st0_ptr->sign == SIGN_POS) {
+				/* poly_2xm1(x) requires 0 < x < 1. */
+				if (poly_2xm1(FPU_st0_ptr, &rv))
+					return;	/* error */
+				reg_mul(&rv, FPU_st0_ptr, FPU_st0_ptr, FULL_PRECISION);
+			} else {
+/* **** Should change poly_2xm1() to at least handle numbers near 0 */
+				/* poly_2xm1(x) doesn't handle negative
+				 * numbers. */
+				/* So we compute (poly_2xm1(x+1)-1)/2, for -1
+				 * < x < 0 */
+				reg_add(FPU_st0_ptr, &CONST_1, &tmp, FULL_PRECISION);
+				poly_2xm1(&tmp, &rv);
+				reg_mul(&rv, &tmp, &tmp, FULL_PRECISION);
+				reg_sub(&tmp, &CONST_1, FPU_st0_ptr, FULL_PRECISION);
+				FPU_st0_ptr->exp--;
+				if (FPU_st0_ptr->exp <= EXP_UNDER)
+					arith_underflow(FPU_st0_ptr);
+			}
+			return;
+		}
+	case TW_Zero:
+		return;
+	case TW_Infinity:
+		if (FPU_st0_ptr->sign == SIGN_NEG) {
+			/* -infinity gives -1 (p16-10) */
+			reg_move(&CONST_1, FPU_st0_ptr);
+			FPU_st0_ptr->sign = SIGN_NEG;
+		}
+		return;
+	default:
+		single_arg_error();
+	}
+}
+
+static void
+fptan(void)
+{
+	FPU_REG *st_new_ptr;
+	int     q;
+	char    arg_sign = FPU_st0_ptr->sign;
+
+	if (STACK_OVERFLOW) {
+		stack_overflow();
+		return;
+	}
+	switch (FPU_st0_tag) {
+	case TW_Valid:
+
+#ifdef DENORM_OPERAND
+		if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		FPU_st0_ptr->sign = SIGN_POS;
+		if ((q = trig_arg(FPU_st0_ptr)) != -1) {
+			if (q & 1)
+				reg_sub(&CONST_1, FPU_st0_ptr, FPU_st0_ptr, FULL_PRECISION);
+
+			poly_tan(FPU_st0_ptr, FPU_st0_ptr);
+
+			FPU_st0_ptr->sign = (q & 1) ^ arg_sign;
+
+			if (FPU_st0_ptr->exp <= EXP_UNDER)
+				arith_underflow(FPU_st0_ptr);
+
+			push();
+			reg_move(&CONST_1, FPU_st0_ptr);
+			setcc(0);
+		} else {
+			/* Operand is out of range */
+			setcc(SW_C2);
+			FPU_st0_ptr->sign = arg_sign;	/* restore st(0) */
+			return;
+		}
+		break;
+	case TW_Infinity:
+		/* Operand is out of range */
+		setcc(SW_C2);
+		FPU_st0_ptr->sign = arg_sign;	/* restore st(0) */
+		return;
+	case TW_Zero:
+		push();
+		reg_move(&CONST_1, FPU_st0_ptr);
+		setcc(0);
+		break;
+	default:
+		single_arg_error();
+		break;
+	}
+}
+
+
+static void
+fxtract(void)
+{
+	FPU_REG *st_new_ptr;
+	register FPU_REG *st1_ptr = FPU_st0_ptr;	/* anticipate */
+
+	if (STACK_OVERFLOW) {
+		stack_overflow();
+		return;
+	}
+	if (!(FPU_st0_tag ^ TW_Valid)) {
+		long    e;
+
+#ifdef DENORM_OPERAND
+		if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		push();
+		reg_move(st1_ptr, FPU_st0_ptr);
+		FPU_st0_ptr->exp = EXP_BIAS;
+		e = st1_ptr->exp - EXP_BIAS;
+		convert_l2reg(&e, st1_ptr);
+		return;
+	} else
+		if (FPU_st0_tag == TW_Zero) {
+			char    sign = FPU_st0_ptr->sign;
+			divide_by_zero(SIGN_NEG, FPU_st0_ptr);
+			push();
+			reg_move(&CONST_Z, FPU_st0_ptr);
+			FPU_st0_ptr->sign = sign;
+			return;
+		} else
+			if (FPU_st0_tag == TW_Infinity) {
+				char    sign = FPU_st0_ptr->sign;
+				FPU_st0_ptr->sign = SIGN_POS;
+				push();
+				reg_move(&CONST_INF, FPU_st0_ptr);
+				FPU_st0_ptr->sign = sign;
+				return;
+			} else
+				if (FPU_st0_tag == TW_NaN) {
+					if (!(FPU_st0_ptr->sigh & 0x40000000)) {	/* Signaling ? */
+						EXCEPTION(EX_Invalid);
+						/* Convert to a QNaN */
+						FPU_st0_ptr->sigh |= 0x40000000;
+					}
+					push();
+					reg_move(st1_ptr, FPU_st0_ptr);
+					return;
+				} else
+					if (FPU_st0_tag == TW_Empty) {
+						/* Is this the correct
+						 * behaviour? */
+						if (control_word & EX_Invalid) {
+							stack_underflow();
+							push();
+							stack_underflow();
+						} else
+							EXCEPTION(EX_StackUnder);
+					}
+#ifdef PARANOID
+					else
+						EXCEPTION(EX_INTERNAL | 0x119);
+#endif				/* PARANOID */
+}
+
+
+static void
+fdecstp(void)
+{
+	top--;			/* FPU_st0_ptr will be fixed in math_emulate()
+				 * before the next instr */
+}
+
+static void
+fincstp(void)
+{
+	top++;			/* FPU_st0_ptr will be fixed in math_emulate()
+				 * before the next instr */
+}
+
+
+static void
+fsqrt_(void)
+{
+	if (!(FPU_st0_tag ^ TW_Valid)) {
+		int     expon;
+
+		if (FPU_st0_ptr->sign == SIGN_NEG) {
+			arith_invalid(FPU_st0_ptr);	/* sqrt(negative) is
+							 * invalid */
+			return;
+		}
+#ifdef DENORM_OPERAND
+		if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		expon = FPU_st0_ptr->exp - EXP_BIAS;
+		FPU_st0_ptr->exp = EXP_BIAS + (expon & 1);	/* make st(0) in  [1.0
+								 * .. 4.0) */
+
+		wm_sqrt(FPU_st0_ptr, control_word);	/* Do the computation */
+
+		FPU_st0_ptr->exp += expon >> 1;
+		FPU_st0_ptr->sign = SIGN_POS;
+	} else
+		if (FPU_st0_tag == TW_Zero)
+			return;
+		else
+			if (FPU_st0_tag == TW_Infinity) {
+				if (FPU_st0_ptr->sign == SIGN_NEG)
+					arith_invalid(FPU_st0_ptr);	/* sqrt(-Infinity) is
+									 * invalid */
+				return;
+			} else {
+				single_arg_error();
+				return;
+			}
+
+}
+
+
+static void
+frndint_(void)
+{
+	if (!(FPU_st0_tag ^ TW_Valid)) {
+		if (FPU_st0_ptr->exp > EXP_BIAS + 63)
+			return;
+
+#ifdef DENORM_OPERAND
+		if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		round_to_int(FPU_st0_ptr);	/* Fortunately, this can't
+						 * overflow to 2^64 */
+		FPU_st0_ptr->exp = EXP_BIAS + 63;
+		normalize(FPU_st0_ptr);
+		return;
+	} else
+		if ((FPU_st0_tag == TW_Zero) || (FPU_st0_tag == TW_Infinity))
+			return;
+		else
+			single_arg_error();
+}
+
+
+static void
+fsin(void)
+{
+	char    arg_sign = FPU_st0_ptr->sign;
+
+	if (FPU_st0_tag == TW_Valid) {
+		int     q;
+		FPU_st0_ptr->sign = SIGN_POS;
+
+#ifdef DENORM_OPERAND
+		if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		if ((q = trig_arg(FPU_st0_ptr)) != -1) {
+			FPU_REG rv;
+
+			if (q & 1)
+				reg_sub(&CONST_1, FPU_st0_ptr, FPU_st0_ptr, FULL_PRECISION);
+
+			poly_sine(FPU_st0_ptr, &rv);
+
+			setcc(0);
+			if (q & 2)
+				rv.sign ^= SIGN_POS ^ SIGN_NEG;
+			rv.sign ^= arg_sign;
+			reg_move(&rv, FPU_st0_ptr);
+
+			if (FPU_st0_ptr->exp <= EXP_UNDER)
+				arith_underflow(FPU_st0_ptr);
+
+			set_precision_flag_up();	/* We do not really know
+							 * if up or down */
+
+			return;
+		} else {
+			/* Operand is out of range */
+			setcc(SW_C2);
+			FPU_st0_ptr->sign = arg_sign;	/* restore st(0) */
+			return;
+		}
+	} else
+		if (FPU_st0_tag == TW_Zero) {
+			setcc(0);
+			return;
+		} else
+			if (FPU_st0_tag == TW_Infinity) {
+				/* Operand is out of range */
+				setcc(SW_C2);
+				FPU_st0_ptr->sign = arg_sign;	/* restore st(0) */
+				return;
+			} else
+				single_arg_error();
+}
+
+
+static int
+f_cos(FPU_REG * arg)
+{
+	char    arg_sign = arg->sign;
+
+	if (arg->tag == TW_Valid) {
+		int     q;
+
+#ifdef DENORM_OPERAND
+		if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+			return 1;
+#endif				/* DENORM_OPERAND */
+
+		arg->sign = SIGN_POS;
+		if ((q = trig_arg(arg)) != -1) {
+			FPU_REG rv;
+
+			if (!(q & 1))
+				reg_sub(&CONST_1, arg, arg, FULL_PRECISION);
+
+			poly_sine(arg, &rv);
+
+			setcc(0);
+			if ((q + 1) & 2)
+				rv.sign ^= SIGN_POS ^ SIGN_NEG;
+			reg_move(&rv, arg);
+
+			set_precision_flag_up();	/* We do not really know
+							 * if up or down */
+
+			return 0;
+		} else {
+			/* Operand is out of range */
+			setcc(SW_C2);
+			arg->sign = arg_sign;	/* restore st(0) */
+			return 1;
+		}
+	} else
+		if (arg->tag == TW_Zero) {
+			reg_move(&CONST_1, arg);
+			setcc(0);
+			return 0;
+		} else
+			if (FPU_st0_tag == TW_Infinity) {
+				/* Operand is out of range */
+				setcc(SW_C2);
+				arg->sign = arg_sign;	/* restore st(0) */
+				return 1;
+			} else {
+				single_arg_error();	/* requires arg ==
+							 * &st(0) */
+				return 1;
+			}
+}
+
+
+static void
+fcos(void)
+{
+	f_cos(FPU_st0_ptr);
+}
+
+
+static void
+fsincos(void)
+{
+	FPU_REG *st_new_ptr;
+	FPU_REG arg;
+
+	if (STACK_OVERFLOW) {
+		stack_overflow();
+		return;
+	}
+	reg_move(FPU_st0_ptr, &arg);
+	if (!f_cos(&arg)) {
+		fsin();
+		push();
+		reg_move(&arg, FPU_st0_ptr);
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+/* The following all require two arguments: st(0) and st(1) */
+
+/* remainder of st(0) / st(1) */
+/* Assumes that st(0) and st(1) are both TW_Valid */
+static void
+fprem_kernel(int round)
+{
+	FPU_REG *st1_ptr = &st(1);
+	char    st1_tag = st1_ptr->tag;
+
+	if (!((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid))) {
+		FPU_REG tmp;
+		int     old_cw = control_word;
+		int     expdif = FPU_st0_ptr->exp - (st1_ptr)->exp;
+
+#ifdef DENORM_OPERAND
+		if (((FPU_st0_ptr->exp <= EXP_UNDER) ||
+			(st1_ptr->exp <= EXP_UNDER)) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		control_word &= ~CW_RC;
+		control_word |= round;
+
+		if (expdif < 64) {
+			/* This should be the most common case */
+			long long q;
+			int     c = 0;
+
+			reg_div(FPU_st0_ptr, st1_ptr, &tmp, FULL_PRECISION);
+
+			round_to_int(&tmp);	/* Fortunately, this can't
+						 * overflow to 2^64 */
+			tmp.exp = EXP_BIAS + 63;
+			q = *(long long *) &(tmp.sigl);
+			normalize(&tmp);
+
+			reg_mul(st1_ptr, &tmp, &tmp, FULL_PRECISION);
+			reg_sub(FPU_st0_ptr, &tmp, FPU_st0_ptr, FULL_PRECISION);
+
+			if (q & 4)
+				c |= SW_C3;
+			if (q & 2)
+				c |= SW_C1;
+			if (q & 1)
+				c |= SW_C0;
+
+			setcc(c);
+		} else {
+			/* There is a large exponent difference ( >= 64 ) */
+			int     N_exp;
+
+			reg_div(FPU_st0_ptr, st1_ptr, &tmp, FULL_PRECISION);
+			/* N is 'a number between 32 and 63' (p26-113) */
+			N_exp = (tmp.exp & 31) + 32;
+			tmp.exp = EXP_BIAS + N_exp;
+
+			round_to_int(&tmp);	/* Fortunately, this can't
+						 * overflow to 2^64 */
+			tmp.exp = EXP_BIAS + 63;
+			normalize(&tmp);
+
+			tmp.exp = EXP_BIAS + expdif - N_exp;
+
+			reg_mul(st1_ptr, &tmp, &tmp, FULL_PRECISION);
+			reg_sub(FPU_st0_ptr, &tmp, FPU_st0_ptr, FULL_PRECISION);
+
+			setcc(SW_C2);
+		}
+		control_word = old_cw;
+
+		if (FPU_st0_ptr->exp <= EXP_UNDER)
+			arith_underflow(FPU_st0_ptr);
+		return;
+	} else
+		if ((FPU_st0_tag == TW_Empty) | (st1_tag == TW_Empty)) {
+			stack_underflow();
+			return;
+		} else
+			if (FPU_st0_tag == TW_Zero) {
+				if (st1_tag == TW_Valid) {
+
+#ifdef DENORM_OPERAND
+					if ((st1_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+						return;
+#endif				/* DENORM_OPERAND */
+
+					setcc(0);
+					return;
+				} else
+					if (st1_tag == TW_Zero) {
+						arith_invalid(FPU_st0_ptr);
+						return;
+					}
+				/* fprem(?,0) always invalid */
+					else
+						if (st1_tag == TW_Infinity) {
+							setcc(0);
+							return;
+						}
+			} else
+				if (FPU_st0_tag == TW_Valid) {
+					if (st1_tag == TW_Zero) {
+						arith_invalid(FPU_st0_ptr);	/* fprem(Valid,Zero) is
+										 * invalid */
+						return;
+					} else
+						if (st1_tag != TW_NaN) {
+#ifdef DENORM_OPERAND
+							if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+								return;
+#endif				/* DENORM_OPERAND */
+
+							if (st1_tag == TW_Infinity) {
+								/* fprem(Valid,
+								 * Infinity)
+								 * is o.k. */
+								setcc(0);
+								return;
+							}
+						}
+				} else
+					if (FPU_st0_tag == TW_Infinity) {
+						if (st1_tag != TW_NaN) {
+							arith_invalid(FPU_st0_ptr);	/* fprem(Infinity,?) is
+											 * invalid */
+							return;
+						}
+					}
+	/* One of the registers must contain a NaN is we got here. */
+
+#ifdef PARANOID
+	if ((FPU_st0_tag != TW_NaN) && (st1_tag != TW_NaN))
+		EXCEPTION(EX_INTERNAL | 0x118);
+#endif				/* PARANOID */
+
+	real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr);
+
+}
+
+
+/* ST(1) <- ST(1) * log ST;  pop ST */
+static void
+fyl2x(void)
+{
+	FPU_REG *st1_ptr = &st(1);
+	char    st1_tag = st1_ptr->tag;
+
+	if (!((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid))) {
+		if (FPU_st0_ptr->sign == SIGN_POS) {
+			int     saved_control, saved_status;
+
+#ifdef DENORM_OPERAND
+			if (((FPU_st0_ptr->exp <= EXP_UNDER) ||
+				(st1_ptr->exp <= EXP_UNDER)) && (denormal_operand()))
+				return;
+#endif				/* DENORM_OPERAND */
+
+			/* We use the general purpose arithmetic, so we need
+			 * to save these. */
+			saved_status = status_word;
+			saved_control = control_word;
+			control_word = FULL_PRECISION;
+
+			poly_l2(FPU_st0_ptr, FPU_st0_ptr);
+
+			/* Enough of the basic arithmetic is done now */
+			control_word = saved_control;
+			status_word = saved_status;
+
+			/* Let the multiply set the flags */
+			reg_mul(FPU_st0_ptr, st1_ptr, st1_ptr, FULL_PRECISION);
+
+			pop();
+			FPU_st0_ptr = &st(0);
+		} else {
+			/* negative	 */
+			pop();
+			FPU_st0_ptr = &st(0);
+			arith_invalid(FPU_st0_ptr);	/* st(0) cannot be
+							 * negative */
+			return;
+		}
+	} else
+		if ((FPU_st0_tag == TW_Empty) || (st1_tag == TW_Empty)) {
+			stack_underflow_pop(1);
+			return;
+		} else
+			if ((FPU_st0_tag == TW_NaN) || (st1_tag == TW_NaN)) {
+				real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
+				pop();
+				return;
+			} else
+				if ((FPU_st0_tag <= TW_Zero) && (st1_tag <= TW_Zero)) {
+					/* one of the args is zero, the other
+					 * valid, or both zero */
+					if (FPU_st0_tag == TW_Zero) {
+						pop();
+						FPU_st0_ptr = &st(0);
+						if (FPU_st0_ptr->tag == TW_Zero)
+							arith_invalid(FPU_st0_ptr);	/* Both args zero is
+											 * invalid */
+#ifdef PECULIAR_486
+						/* This case is not
+						 * specifically covered in the
+						 * manual, but divide-by-zero
+						 * would seem to be the best
+						 * response. However, a real
+						 * 80486 does it this way... */
+						else
+							if (FPU_st0_ptr->tag == TW_Infinity) {
+								reg_move(&CONST_INF, FPU_st0_ptr);
+								return;
+							}
+#endif				/* PECULIAR_486 */
+							else
+								divide_by_zero(st1_ptr->sign ^ SIGN_NEG ^ SIGN_POS, FPU_st0_ptr);
+						return;
+					} else {
+						/* st(1) contains zero, st(0)
+						 * valid <> 0 */
+						/* Zero is the valid answer */
+						char    sign = st1_ptr->sign;
+
+#ifdef DENORM_OPERAND
+						if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+							return;
+#endif				/* DENORM_OPERAND */
+						if (FPU_st0_ptr->sign == SIGN_NEG) {
+							pop();
+							FPU_st0_ptr = &st(0);
+							arith_invalid(FPU_st0_ptr);	/* log(negative) */
+							return;
+						}
+						if (FPU_st0_ptr->exp < EXP_BIAS)
+							sign ^= SIGN_NEG ^ SIGN_POS;
+						pop();
+						FPU_st0_ptr = &st(0);
+						reg_move(&CONST_Z, FPU_st0_ptr);
+						FPU_st0_ptr->sign = sign;
+						return;
+					}
+				}
+	/* One or both arg must be an infinity */
+				else
+					if (FPU_st0_tag == TW_Infinity) {
+						if ((FPU_st0_ptr->sign == SIGN_NEG) || (st1_tag == TW_Zero)) {
+							pop();
+							FPU_st0_ptr = &st(0);
+							arith_invalid(FPU_st0_ptr);	/* log(-infinity) or
+											 * 0*log(infinity) */
+							return;
+						} else {
+							char    sign = st1_ptr->sign;
+
+#ifdef DENORM_OPERAND
+							if ((st1_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+								return;
+#endif				/* DENORM_OPERAND */
+
+							pop();
+							FPU_st0_ptr = &st(0);
+							reg_move(&CONST_INF, FPU_st0_ptr);
+							FPU_st0_ptr->sign = sign;
+							return;
+						}
+					}
+	/* st(1) must be infinity here */
+					else
+						if ((FPU_st0_tag == TW_Valid) && (FPU_st0_ptr->sign == SIGN_POS)) {
+							if (FPU_st0_ptr->exp >= EXP_BIAS) {
+								if ((FPU_st0_ptr->exp == EXP_BIAS) &&
+								    (FPU_st0_ptr->sigh == 0x80000000) &&
+								    (FPU_st0_ptr->sigl == 0)) {
+									/* st(0
+									 * )
+									 * hold
+									 * s
+									 * 1.0 */
+									pop();
+									FPU_st0_ptr = &st(0);
+									arith_invalid(FPU_st0_ptr);	/* infinity*log(1) */
+									return;
+								}
+								/* st(0) is
+								 * positive
+								 * and > 1.0 */
+								pop();
+							} else {
+								/* st(0) is
+								 * positive
+								 * and < 1.0 */
+
+#ifdef DENORM_OPERAND
+								if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+									return;
+#endif				/* DENORM_OPERAND */
+
+								st1_ptr->sign ^= SIGN_NEG;
+								pop();
+							}
+							return;
+						} else {
+							/* st(0) must be zero
+							 * or negative */
+							if (FPU_st0_ptr->tag == TW_Zero) {
+								pop();
+								FPU_st0_ptr = st1_ptr;
+								st1_ptr->sign ^= SIGN_NEG ^ SIGN_POS;
+								/* This should
+								 * be invalid,
+								 * but a real
+								 * 80486 is
+								 * happy with
+								 * it. */
+#ifndef PECULIAR_486
+								divide_by_zero(st1_ptr->sign, FPU_st0_ptr);
+#endif				/* PECULIAR_486 */
+							} else {
+								pop();
+								FPU_st0_ptr = st1_ptr;
+								arith_invalid(FPU_st0_ptr);	/* log(negative) */
+							}
+							return;
+						}
+}
+
+
+static void
+fpatan(void)
+{
+	FPU_REG *st1_ptr = &st(1);
+	char    st1_tag = st1_ptr->tag;
+
+	if (!((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid))) {
+		int     saved_control, saved_status;
+		FPU_REG sum;
+		int     quadrant = st1_ptr->sign | ((FPU_st0_ptr->sign) << 1);
+
+#ifdef DENORM_OPERAND
+		if (((FPU_st0_ptr->exp <= EXP_UNDER) ||
+			(st1_ptr->exp <= EXP_UNDER)) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		/* We use the general purpose arithmetic so we need to save
+		 * these. */
+		saved_status = status_word;
+		saved_control = control_word;
+		control_word = FULL_PRECISION;
+
+		st1_ptr->sign = FPU_st0_ptr->sign = SIGN_POS;
+		if (compare(st1_ptr) == COMP_A_lt_B) {
+			quadrant |= 4;
+			reg_div(FPU_st0_ptr, st1_ptr, &sum, FULL_PRECISION);
+		} else
+			reg_div(st1_ptr, FPU_st0_ptr, &sum, FULL_PRECISION);
+
+		poly_atan(&sum);
+
+		if (quadrant & 4) {
+			reg_sub(&CONST_PI2, &sum, &sum, FULL_PRECISION);
+		}
+		if (quadrant & 2) {
+			reg_sub(&CONST_PI, &sum, &sum, FULL_PRECISION);
+		}
+		if (quadrant & 1)
+			sum.sign ^= SIGN_POS ^ SIGN_NEG;
+
+		/* All of the basic arithmetic is done now */
+		control_word = saved_control;
+		status_word = saved_status;
+
+		reg_move(&sum, st1_ptr);
+	} else
+		if ((FPU_st0_tag == TW_Empty) || (st1_tag == TW_Empty)) {
+			stack_underflow_pop(1);
+			return;
+		} else
+			if ((FPU_st0_tag == TW_NaN) || (st1_tag == TW_NaN)) {
+				real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
+				pop();
+				return;
+			} else
+				if ((FPU_st0_tag == TW_Infinity) || (st1_tag == TW_Infinity)) {
+					char    sign = st1_ptr->sign;
+					if (FPU_st0_tag == TW_Infinity) {
+						if (st1_tag == TW_Infinity) {
+							if (FPU_st0_ptr->sign == SIGN_POS) {
+								reg_move(&CONST_PI4, st1_ptr);
+							} else
+								reg_add(&CONST_PI4, &CONST_PI2, st1_ptr, FULL_PRECISION);
+						} else {
+
+#ifdef DENORM_OPERAND
+							if ((st1_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+								return;
+#endif				/* DENORM_OPERAND */
+
+							if (FPU_st0_ptr->sign == SIGN_POS) {
+								reg_move(&CONST_Z, st1_ptr);
+								pop();
+								return;
+							} else
+								reg_move(&CONST_PI, st1_ptr);
+						}
+					} else {
+						/* st(1) is infinity, st(0)
+						 * not infinity */
+#ifdef DENORM_OPERAND
+						if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+							return;
+#endif				/* DENORM_OPERAND */
+
+						reg_move(&CONST_PI2, st1_ptr);
+					}
+					st1_ptr->sign = sign;
+				} else
+					if (st1_tag == TW_Zero) {
+						/* st(0) must be valid or zero */
+						char    sign = st1_ptr->sign;
+
+#ifdef DENORM_OPERAND
+						if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+							return;
+#endif				/* DENORM_OPERAND */
+
+						if (FPU_st0_ptr->sign == SIGN_POS) {
+							reg_move(&CONST_Z, st1_ptr);
+							pop();
+							return;
+						} else
+							reg_move(&CONST_PI, st1_ptr);
+						st1_ptr->sign = sign;
+					} else
+						if (FPU_st0_tag == TW_Zero) {
+							/* st(1) must be
+							 * TW_Valid here */
+							char    sign = st1_ptr->sign;
+
+#ifdef DENORM_OPERAND
+							if ((st1_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+								return;
+#endif				/* DENORM_OPERAND */
+
+							reg_move(&CONST_PI2, st1_ptr);
+							st1_ptr->sign = sign;
+						}
+#ifdef PARANOID
+						else
+							EXCEPTION(EX_INTERNAL | 0x220);
+#endif				/* PARANOID */
+
+	pop();
+	set_precision_flag_up();/* We do not really know if up or down */
+}
+
+
+static void
+fprem(void)
+{
+	fprem_kernel(RC_CHOP);
+}
+
+
+static void
+fprem1(void)
+{
+	fprem_kernel(RC_RND);
+}
+
+
+static void
+fyl2xp1(void)
+{
+	FPU_REG *st1_ptr = &st(1);
+	char    st1_tag = st1_ptr->tag;
+
+	if (!((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid))) {
+		int     saved_control, saved_status;
+
+#ifdef DENORM_OPERAND
+		if (((FPU_st0_ptr->exp <= EXP_UNDER) ||
+			(st1_ptr->exp <= EXP_UNDER)) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		/* We use the general purpose arithmetic so we need to save
+		 * these. */
+		saved_status = status_word;
+		saved_control = control_word;
+		control_word = FULL_PRECISION;
+
+		if (poly_l2p1(FPU_st0_ptr, FPU_st0_ptr)) {
+			arith_invalid(st1_ptr);	/* poly_l2p1() returned
+						 * invalid */
+			pop();
+			return;
+		}
+		/* Enough of the basic arithmetic is done now */
+		control_word = saved_control;
+		status_word = saved_status;
+
+		/* Let the multiply set the flags */
+		reg_mul(FPU_st0_ptr, st1_ptr, st1_ptr, FULL_PRECISION);
+
+		pop();
+	} else
+		if ((FPU_st0_tag == TW_Empty) | (st1_tag == TW_Empty)) {
+			stack_underflow_pop(1);
+			return;
+		} else
+			if (FPU_st0_tag == TW_Zero) {
+				if (st1_tag <= TW_Zero) {
+
+#ifdef DENORM_OPERAND
+					if ((st1_tag == TW_Valid) && (st1_ptr->exp <= EXP_UNDER) &&
+					    (denormal_operand()))
+						return;
+#endif				/* DENORM_OPERAND */
+
+					st1_ptr->sign ^= FPU_st0_ptr->sign;
+					reg_move(FPU_st0_ptr, st1_ptr);
+				} else
+					if (st1_tag == TW_Infinity) {
+						arith_invalid(st1_ptr);	/* Infinity*log(1) */
+						pop();
+						return;
+					} else
+						if (st1_tag == TW_NaN) {
+							real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
+							pop();
+							return;
+						}
+#ifdef PARANOID
+						else {
+							EXCEPTION(EX_INTERNAL | 0x116);
+							return;
+						}
+#endif				/* PARANOID */
+				pop();
+				return;
+			} else
+				if (FPU_st0_tag == TW_Valid) {
+					if (st1_tag == TW_Zero) {
+						if (FPU_st0_ptr->sign == SIGN_NEG) {
+							if (FPU_st0_ptr->exp >= EXP_BIAS) {
+								/* st(0) holds
+								 * <= -1.0 */
+								arith_invalid(st1_ptr);	/* infinity*log(1) */
+								pop();
+								return;
+							}
+#ifdef DENORM_OPERAND
+							if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+								return;
+#endif				/* DENORM_OPERAND */
+							st1_ptr->sign ^= SIGN_POS ^ SIGN_NEG;
+							pop();
+							return;
+						}
+#ifdef DENORM_OPERAND
+						if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+							return;
+#endif				/* DENORM_OPERAND */
+						pop();
+						return;
+					}
+					if (st1_tag == TW_Infinity) {
+						if (FPU_st0_ptr->sign == SIGN_NEG) {
+							if ((FPU_st0_ptr->exp >= EXP_BIAS) &&
+							    !((FPU_st0_ptr->sigh == 0x80000000) &&
+								(FPU_st0_ptr->sigl == 0))) {
+								/* st(0) holds
+								 * < -1.0 */
+								arith_invalid(st1_ptr);
+								pop();
+								return;
+							}
+#ifdef DENORM_OPERAND
+							if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+								return;
+#endif				/* DENORM_OPERAND */
+							st1_ptr->sign ^= SIGN_POS ^ SIGN_NEG;
+							pop();
+							return;
+						}
+#ifdef DENORM_OPERAND
+						if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+							return;
+#endif				/* DENORM_OPERAND */
+						pop();
+						return;
+					}
+					if (st1_tag == TW_NaN) {
+						real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
+						pop();
+						return;
+					}
+				} else
+					if (FPU_st0_tag == TW_NaN) {
+						real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
+						pop();
+						return;
+					} else
+						if (FPU_st0_tag == TW_Infinity) {
+							if (st1_tag == TW_NaN) {
+								real_2op_NaN(FPU_st0_ptr, st1_ptr, st1_ptr);
+								pop();
+								return;
+							} else
+								if ((FPU_st0_ptr->sign == SIGN_NEG) ||
+								    (st1_tag == TW_Zero)) {
+									arith_invalid(st1_ptr);	/* log(infinity) */
+									pop();
+									return;
+								}
+							/* st(1) must be valid
+							 * here. */
+
+#ifdef DENORM_OPERAND
+							if ((st1_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+								return;
+#endif				/* DENORM_OPERAND */
+
+							/* The Manual says
+							 * that log(Infinity)
+							 * is invalid, but a
+							 * real 80486 sensibly
+							 * says that it is
+							 * o.k. */
+							{
+								char    sign = st1_ptr->sign;
+								reg_move(&CONST_INF, st1_ptr);
+								st1_ptr->sign = sign;
+							}
+							pop();
+							return;
+						}
+#ifdef PARANOID
+						else {
+							EXCEPTION(EX_INTERNAL | 0x117);
+						}
+#endif				/* PARANOID */
+}
+
+
+static void
+fscale(void)
+{
+	FPU_REG *st1_ptr = &st(1);
+	char    st1_tag = st1_ptr->tag;
+	int     old_cw = control_word;
+
+	if (!((FPU_st0_tag ^ TW_Valid) | (st1_tag ^ TW_Valid))) {
+		long    scale;
+		FPU_REG tmp;
+
+#ifdef DENORM_OPERAND
+		if (((FPU_st0_ptr->exp <= EXP_UNDER) ||
+			(st1_ptr->exp <= EXP_UNDER)) && (denormal_operand()))
+			return;
+#endif				/* DENORM_OPERAND */
+
+		if (st1_ptr->exp > EXP_BIAS + 30) {
+			/* 2^31 is far too large, would require 2^(2^30) or
+			 * 2^(-2^30) */
+			char    sign;
+
+			if (st1_ptr->sign == SIGN_POS) {
+				EXCEPTION(EX_Overflow);
+				sign = FPU_st0_ptr->sign;
+				reg_move(&CONST_INF, FPU_st0_ptr);
+				FPU_st0_ptr->sign = sign;
+			} else {
+				EXCEPTION(EX_Underflow);
+				sign = FPU_st0_ptr->sign;
+				reg_move(&CONST_Z, FPU_st0_ptr);
+				FPU_st0_ptr->sign = sign;
+			}
+			return;
+		}
+		control_word &= ~CW_RC;
+		control_word |= RC_CHOP;
+		reg_move(st1_ptr, &tmp);
+		round_to_int(&tmp);	/* This can never overflow here */
+		control_word = old_cw;
+		scale = st1_ptr->sign ? -tmp.sigl : tmp.sigl;
+		scale += FPU_st0_ptr->exp;
+		FPU_st0_ptr->exp = scale;
+
+		/* Use round_reg() to properly detect under/overflow etc */
+		round_reg(FPU_st0_ptr, 0, control_word);
+
+		return;
+	} else
+		if (FPU_st0_tag == TW_Valid) {
+			if (st1_tag == TW_Zero) {
+
+#ifdef DENORM_OPERAND
+				if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+					return;
+#endif				/* DENORM_OPERAND */
+
+				return;
+			}
+			if (st1_tag == TW_Infinity) {
+				char    sign = st1_ptr->sign;
+
+#ifdef DENORM_OPERAND
+				if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+					return;
+#endif				/* DENORM_OPERAND */
+
+				if (sign == SIGN_POS) {
+					reg_move(&CONST_INF, FPU_st0_ptr);
+				} else
+					reg_move(&CONST_Z, FPU_st0_ptr);
+				FPU_st0_ptr->sign = sign;
+				return;
+			}
+			if (st1_tag == TW_NaN) {
+				real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr);
+				return;
+			}
+		} else
+			if (FPU_st0_tag == TW_Zero) {
+				if (st1_tag == TW_Valid) {
+
+#ifdef DENORM_OPERAND
+					if ((st1_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+						return;
+#endif				/* DENORM_OPERAND */
+
+					return;
+				} else
+					if (st1_tag == TW_Zero) {
+						return;
+					} else
+						if (st1_tag == TW_Infinity) {
+							if (st1_ptr->sign == SIGN_NEG)
+								return;
+							else {
+								arith_invalid(FPU_st0_ptr);	/* Zero scaled by
+												 * +Infinity */
+								return;
+							}
+						} else
+							if (st1_tag == TW_NaN) {
+								real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr);
+								return;
+							}
+			} else
+				if (FPU_st0_tag == TW_Infinity) {
+					if (st1_tag == TW_Valid) {
+
+#ifdef DENORM_OPERAND
+						if ((st1_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+							return;
+#endif				/* DENORM_OPERAND */
+
+						return;
+					}
+					if (((st1_tag == TW_Infinity) && (st1_ptr->sign == SIGN_POS))
+					    || (st1_tag == TW_Zero))
+						return;
+					else
+						if (st1_tag == TW_Infinity) {
+							arith_invalid(FPU_st0_ptr);	/* Infinity scaled by
+											 * -Infinity */
+							return;
+						} else
+							if (st1_tag == TW_NaN) {
+								real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr);
+								return;
+							}
+				} else
+					if (FPU_st0_tag == TW_NaN) {
+						if (st1_tag != TW_Empty) {
+							real_2op_NaN(FPU_st0_ptr, st1_ptr, FPU_st0_ptr);
+							return;
+						}
+					}
+#ifdef PARANOID
+	if (!((FPU_st0_tag == TW_Empty) || (st1_tag == TW_Empty))) {
+		EXCEPTION(EX_INTERNAL | 0x115);
+		return;
+	}
+#endif
+
+	/* At least one of st(0), st(1) must be empty */
+	stack_underflow();
+
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static FUNC trig_table_a[] = {
+	f2xm1, fyl2x, fptan, fpatan, fxtract, fprem1, fdecstp, fincstp
+};
+
+void
+trig_a(void)
+{
+	(trig_table_a[FPU_rm]) ();
+}
+
+
+static FUNC trig_table_b[] =
+{
+	fprem, fyl2xp1, fsqrt_, fsincos, frndint_, fscale, fsin, fcos
+};
+
+void
+trig_b(void)
+{
+	(trig_table_b[FPU_rm]) ();
+}
diff --git a/sys/gnu/i386/fpemul/get_address.c b/sys/gnu/i386/fpemul/get_address.c
new file mode 100644
index 0000000..9de2c47
--- /dev/null
+++ b/sys/gnu/i386/fpemul/get_address.c
@@ -0,0 +1,190 @@
+/*
+ *  get_address.c
+ *
+ * Get the effective address from an FPU instruction.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*---------------------------------------------------------------------------+
+ | Note:                                                                     |
+ |    The file contains code which accesses user memory.                     |
+ |    Emulator static data may change when user memory is accessed, due to   |
+ |    other processes using the emulator while swapping is in progress.      |
+ +---------------------------------------------------------------------------*/
+
+#include "param.h"
+#include "proc.h"
+#include "systm.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+#include "machine/reg.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "exception.h"
+
+static int reg_offset[] = {
+tEAX, tECX, tEDX, tEBX, tESP, tEBP, tESI, tEDI};
+#define REG_(x) (*(((int*)FPU_info) + reg_offset[(x)]))
+
+void   *FPU_data_address;
+
+
+/* Decode the SIB byte. This function assumes mod != 0 */
+static void *
+sib(int mod)
+{
+	unsigned char ss, index, base;
+	long    offset;
+
+	REENTRANT_CHECK(OFF);
+	base = fubyte((char *) FPU_EIP);	/* The SIB byte */
+	REENTRANT_CHECK(ON);
+	FPU_EIP++;
+	ss = base >> 6;
+	index = (base >> 3) & 7;
+	base &= 7;
+
+	if ((mod == 0) && (base == 5))
+		offset = 0;	/* No base register */
+	else
+		offset = REG_(base);
+
+	if (index == 4) {
+		/* No index register */
+		/* A non-zero ss is illegal */
+		if (ss)
+			EXCEPTION(EX_Invalid);
+	} else {
+		offset += (REG_(index)) << ss;
+	}
+
+	if (mod == 1) {
+		/* 8 bit signed displacement */
+		REENTRANT_CHECK(OFF);
+		offset += (signed char) fubyte((char *) FPU_EIP);
+		REENTRANT_CHECK(ON);
+		FPU_EIP++;
+	} else
+		if (mod == 2 || base == 5) {	/* The second condition also
+						 * has mod==0 */
+			/* 32 bit displacment */
+			REENTRANT_CHECK(OFF);
+			offset += (signed) fuword((unsigned long *) FPU_EIP);
+			REENTRANT_CHECK(ON);
+			FPU_EIP += 4;
+		}
+	return (void *) offset;
+}
+
+
+/*
+       MOD R/M byte:  MOD == 3 has a special use for the FPU
+                      SIB byte used iff R/M = 100b
+
+       7   6   5   4   3   2   1   0
+       .....   .........   .........
+        MOD    OPCODE(2)     R/M
+
+
+       SIB byte
+
+       7   6   5   4   3   2   1   0
+       .....   .........   .........
+        SS      INDEX        BASE
+
+*/
+
+void
+get_address(unsigned char FPU_modrm)
+{
+	unsigned char mod;
+	long   *cpu_reg_ptr;
+	int     offset = 0;	/* Initialized just to stop compiler warnings. */
+
+	mod = (FPU_modrm >> 6) & 3;
+
+	if (FPU_rm == 4 && mod != 3) {
+		FPU_data_address = sib(mod);
+		return;
+	}
+	cpu_reg_ptr = (long *) &REG_(FPU_rm);
+	switch (mod) {
+	case 0:
+		if (FPU_rm == 5) {
+			/* Special case: disp32 */
+			REENTRANT_CHECK(OFF);
+			offset = fuword((unsigned long *) FPU_EIP);
+			REENTRANT_CHECK(ON);
+			FPU_EIP += 4;
+			FPU_data_address = (void *) offset;
+			return;
+		} else {
+			FPU_data_address = (void *) *cpu_reg_ptr;	/* Just return the
+									 * contents of the cpu
+									 * register */
+			return;
+		}
+	case 1:
+		/* 8 bit signed displacement */
+		REENTRANT_CHECK(OFF);
+		offset = (signed char) fubyte((char *) FPU_EIP);
+		REENTRANT_CHECK(ON);
+		FPU_EIP++;
+		break;
+	case 2:
+		/* 32 bit displacement */
+		REENTRANT_CHECK(OFF);
+		offset = (signed) fuword((unsigned long *) FPU_EIP);
+		REENTRANT_CHECK(ON);
+		FPU_EIP += 4;
+		break;
+	case 3:
+		/* Not legal for the FPU */
+		EXCEPTION(EX_Invalid);
+	}
+
+	FPU_data_address = offset + (char *) *cpu_reg_ptr;
+}
diff --git a/sys/gnu/i386/fpemul/load_store.c b/sys/gnu/i386/fpemul/load_store.c
new file mode 100644
index 0000000..799a319
--- /dev/null
+++ b/sys/gnu/i386/fpemul/load_store.c
@@ -0,0 +1,256 @@
+/*
+ *  load_store.c
+ *
+ * This file contains most of the code to interpret the FPU instructions
+ * which load and store from user memory.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*---------------------------------------------------------------------------+
+ | Note:                                                                     |
+ |    The file contains code which accesses user memory.                     |
+ |    Emulator static data may change when user memory is accessed, due to   |
+ |    other processes using the emulator while swapping is in progress.      |
+ +---------------------------------------------------------------------------*/
+
+#include "param.h"
+#include "proc.h"
+#include "systm.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "exception.h"
+#include "status_w.h"
+
+
+#define _NONE_ 0		/* FPU_st0_ptr etc not needed */
+#define _REG0_ 1		/* Will be storing st(0) */
+#define _PUSH_ 3		/* Need to check for space to push onto stack */
+#define _null_ 4		/* Function illegal or not implemented */
+
+#define pop_0()	{ pop_ptr->tag = TW_Empty; top++; }
+
+
+static unsigned char type_table[32] = {
+	_PUSH_, _PUSH_, _PUSH_, _PUSH_,
+	_null_, _null_, _null_, _null_,
+	_REG0_, _REG0_, _REG0_, _REG0_,
+	_REG0_, _REG0_, _REG0_, _REG0_,
+	_NONE_, _null_, _NONE_, _PUSH_,
+	_NONE_, _PUSH_, _null_, _PUSH_,
+	_NONE_, _null_, _NONE_, _REG0_,
+	_NONE_, _REG0_, _NONE_, _REG0_
+};
+
+void
+load_store_instr(char type)
+{
+	FPU_REG *pop_ptr;	/* We need a version of FPU_st0_ptr which
+				 * won't change. */
+
+	pop_ptr = NULL;		/* Initialized just to stop compiler warnings. */
+
+
+	switch (type_table[(int) (unsigned) type]) {
+	case _NONE_:
+		break;
+	case _REG0_:
+		pop_ptr = &st(0);	/* Some of these instructions pop
+					 * after storing */
+
+		FPU_st0_ptr = pop_ptr;	/* Set the global variables. */
+		FPU_st0_tag = FPU_st0_ptr->tag;
+		break;
+	case _PUSH_:
+		{
+			pop_ptr = &st(-1);
+			if (pop_ptr->tag != TW_Empty) {
+				stack_overflow();
+				return;
+			}
+			top--;
+		}
+		break;
+	case _null_:
+		return Un_impl();
+#ifdef PARANOID
+	default:
+		return EXCEPTION(EX_INTERNAL);
+#endif				/* PARANOID */
+	}
+
+	switch (type) {
+	case 000:		/* fld m32real */
+		reg_load_single();
+		setcc(0);	/* Clear the SW_C1 bit, "other bits undefined" */
+		reg_move(&FPU_loaded_data, pop_ptr);
+		break;
+	case 001:		/* fild m32int */
+		reg_load_int32();
+		setcc(0);	/* Clear the SW_C1 bit, "other bits undefined" */
+		reg_move(&FPU_loaded_data, pop_ptr);
+		break;
+	case 002:		/* fld m64real */
+		reg_load_double();
+		setcc(0);	/* Clear the SW_C1 bit, "other bits undefined" */
+		reg_move(&FPU_loaded_data, pop_ptr);
+		break;
+	case 003:		/* fild m16int */
+		reg_load_int16();
+		setcc(0);	/* Clear the SW_C1 bit, "other bits undefined" */
+		reg_move(&FPU_loaded_data, pop_ptr);
+		break;
+	case 010:		/* fst m32real */
+		reg_store_single();
+		break;
+	case 011:		/* fist m32int */
+		reg_store_int32();
+		break;
+	case 012:		/* fst m64real */
+		reg_store_double();
+		break;
+	case 013:		/* fist m16int */
+		reg_store_int16();
+		break;
+	case 014:		/* fstp m32real */
+		if (reg_store_single())
+			pop_0();/* pop only if the number was actually stored
+				 * (see the 80486 manual p16-28) */
+		break;
+	case 015:		/* fistp m32int */
+		if (reg_store_int32())
+			pop_0();/* pop only if the number was actually stored
+				 * (see the 80486 manual p16-28) */
+		break;
+	case 016:		/* fstp m64real */
+		if (reg_store_double())
+			pop_0();/* pop only if the number was actually stored
+				 * (see the 80486 manual p16-28) */
+		break;
+	case 017:		/* fistp m16int */
+		if (reg_store_int16())
+			pop_0();/* pop only if the number was actually stored
+				 * (see the 80486 manual p16-28) */
+		break;
+	case 020:		/* fldenv  m14/28byte */
+		fldenv();
+		break;
+	case 022:		/* frstor m94/108byte */
+		frstor();
+		break;
+	case 023:		/* fbld m80dec */
+		reg_load_bcd();
+		setcc(0);	/* Clear the SW_C1 bit, "other bits undefined" */
+		reg_move(&FPU_loaded_data, pop_ptr);
+		break;
+	case 024:		/* fldcw */
+		REENTRANT_CHECK(OFF);
+		control_word = fuword((unsigned short *) FPU_data_address);
+		REENTRANT_CHECK(ON);
+#ifdef NO_UNDERFLOW_TRAP
+		if (!(control_word & EX_Underflow)) {
+			control_word |= EX_Underflow;
+		}
+#endif
+		FPU_data_address = (void *) data_operand_offset;	/* We want no net effect */
+		FPU_entry_eip = ip_offset;	/* We want no net effect */
+		break;
+	case 025:		/* fld m80real */
+		reg_load_extended();
+		setcc(0);	/* Clear the SW_C1 bit, "other bits undefined" */
+		reg_move(&FPU_loaded_data, pop_ptr);
+		break;
+	case 027:		/* fild m64int */
+		reg_load_int64();
+		setcc(0);	/* Clear the SW_C1 bit, "other bits undefined" */
+		reg_move(&FPU_loaded_data, pop_ptr);
+		break;
+	case 030:		/* fstenv  m14/28byte */
+		fstenv();
+		FPU_data_address = (void *) data_operand_offset;	/* We want no net effect */
+		FPU_entry_eip = ip_offset;	/* We want no net effect */
+		break;
+	case 032:		/* fsave */
+		fsave();
+		FPU_data_address = (void *) data_operand_offset;	/* We want no net effect */
+		FPU_entry_eip = ip_offset;	/* We want no net effect */
+		break;
+	case 033:		/* fbstp m80dec */
+		if (reg_store_bcd())
+			pop_0();/* pop only if the number was actually stored
+				 * (see the 80486 manual p16-28) */
+		break;
+	case 034:		/* fstcw m16int */
+		REENTRANT_CHECK(OFF);
+/*		    verify_area(VERIFY_WRITE, FPU_data_address, 2);*/
+		suword( (short *) FPU_data_address,control_word);
+		REENTRANT_CHECK(ON);
+		FPU_data_address = (void *) data_operand_offset;	/* We want no net effect */
+		FPU_entry_eip = ip_offset;	/* We want no net effect */
+		break;
+	case 035:		/* fstp m80real */
+		if (reg_store_extended())
+			pop_0();/* pop only if the number was actually stored
+				 * (see the 80486 manual p16-28) */
+		break;
+	case 036:		/* fstsw m2byte */
+		status_word &= ~SW_Top;
+		status_word |= (top & 7) << SW_Top_Shift;
+		REENTRANT_CHECK(OFF);
+/*		    verify_area(VERIFY_WRITE, FPU_data_address, 2);*/
+		suword( (short *) FPU_data_address,status_word);
+		REENTRANT_CHECK(ON);
+		FPU_data_address = (void *) data_operand_offset;	/* We want no net effect */
+		FPU_entry_eip = ip_offset;	/* We want no net effect */
+		break;
+	case 037:		/* fistp m64int */
+		if (reg_store_int64())
+			pop_0();/* pop only if the number was actually stored
+				 * (see the 80486 manual p16-28) */
+		break;
+	}
+}
diff --git a/sys/gnu/i386/fpemul/math_emu.h b/sys/gnu/i386/fpemul/math_emu.h
new file mode 100644
index 0000000..825a721
--- /dev/null
+++ b/sys/gnu/i386/fpemul/math_emu.h
@@ -0,0 +1,41 @@
+#ifndef _MATH_EMU_H
+#define _MATH_EMU_H
+
+struct fpu_reg {
+	char    sign;
+	char    tag;
+	long    exp;
+	u_long  sigl;
+	u_long  sigh;
+};
+
+union i387_union {
+	struct i387_hard_struct {
+		long    cwd;
+		long    swd;
+		long    twd;
+		long    fip;
+		long    fcs;
+		long    foo;
+		long    fos;
+		long    st_space[20];	/* 8*10 bytes for each FP-reg = 80
+					 * bytes */
+	}       hard;
+	struct i387_soft_struct {
+		long    cwd;
+		long    swd;
+		long    twd;
+		long    fip;
+		long    fcs;
+		long    foo;
+		long    fos;
+		long    top;
+		struct fpu_reg regs[8];	/* 8*16 bytes for each FP-reg = 128
+					 * bytes */
+		unsigned char lookahead;
+		struct trapframe *frame;
+		unsigned long entry_eip;
+		int     orig_eip;
+	}       soft;
+};
+#endif
diff --git a/sys/gnu/i386/fpemul/poly_2xm1.c b/sys/gnu/i386/fpemul/poly_2xm1.c
new file mode 100644
index 0000000..da42fca
--- /dev/null
+++ b/sys/gnu/i386/fpemul/poly_2xm1.c
@@ -0,0 +1,128 @@
+/*
+ *  poly_2xm1.c
+ *
+ * Function to compute 2^x-1 by a polynomial approximation.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "exception.h"
+#include "reg_constant.h"
+#include "fpu_emu.h"
+
+
+
+#define	HIPOWER	13
+static unsigned short lterms[HIPOWER][4] =
+{
+	{0x79b5, 0xd1cf, 0x17f7, 0xb172},
+	{0x1b56, 0x058b, 0x7bff, 0x3d7f},
+	{0x8bb0, 0x8250, 0x846b, 0x0e35},
+	{0xbc65, 0xf747, 0x556d, 0x0276},
+	{0x17cb, 0x9e39, 0x61ff, 0x0057},
+	{0xe018, 0x9776, 0x1848, 0x000a},
+	{0x66f2, 0xff30, 0xffe5, 0x0000},
+	{0x682f, 0xffb6, 0x162b, 0x0000},
+	{0xb7ca, 0x2956, 0x01b5, 0x0000},
+	{0xcd3e, 0x4817, 0x001e, 0x0000},
+	{0xb7e2, 0xecbe, 0x0001, 0x0000},
+	{0x0ed5, 0x1a27, 0x0000, 0x0000},
+	{0x101d, 0x0222, 0x0000, 0x0000},
+};
+
+
+/*--- poly_2xm1() -----------------------------------------------------------+
+ |                                                                           |
+ +---------------------------------------------------------------------------*/
+int
+poly_2xm1(FPU_REG * arg, FPU_REG * result)
+{
+	short   exponent;
+	long long Xll;
+	FPU_REG accum;
+
+
+	exponent = arg->exp - EXP_BIAS;
+
+	if (arg->tag == TW_Zero) {
+		/* Return 0.0 */
+		reg_move(&CONST_Z, result);
+		return 0;
+	}
+	if (exponent >= 0) {	/* Can't hack a number >= 1.0 */
+		arith_invalid(result);	/* Number too large */
+		return 1;
+	}
+	if (arg->sign != SIGN_POS) {	/* Can't hack a number < 0.0 */
+		arith_invalid(result);	/* Number negative */
+		return 1;
+	}
+	if (exponent < -64) {
+		reg_move(&CONST_LN2, result);
+		return 0;
+	}
+	*(unsigned *) &Xll = arg->sigl;
+	*(((unsigned *) &Xll) + 1) = arg->sigh;
+	if (exponent < -1) {
+		/* shift the argument right by the required places */
+		if (shrx(&Xll, -1 - exponent) >= (unsigned)0x80000000)
+			Xll++;	/* round up */
+	}
+	*(short *) &(accum.sign) = 0;	/* will be a valid positive nr with
+					 * expon = 0 */
+	accum.exp = 0;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial((unsigned *) &accum.sigl, (unsigned *) &Xll, lterms, HIPOWER - 1);
+
+	/* Convert to 64 bit signed-compatible */
+	accum.exp += EXP_BIAS - 1;
+
+	reg_move(&accum, result);
+
+	normalize(result);
+
+	return 0;
+
+}
diff --git a/sys/gnu/i386/fpemul/poly_atan.c b/sys/gnu/i386/fpemul/poly_atan.c
new file mode 100644
index 0000000..8cc98fa
--- /dev/null
+++ b/sys/gnu/i386/fpemul/poly_atan.c
@@ -0,0 +1,239 @@
+/*
+ *  p_atan.c
+ *
+ * Compute the tan of a FPU_REG, using a polynomial approximation.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "exception.h"
+#include "reg_constant.h"
+#include "fpu_emu.h"
+#include "control_w.h"
+
+
+#define	HIPOWERon	6	/* odd poly, negative terms */
+static unsigned oddnegterms[HIPOWERon][2] =
+{
+	{0x00000000, 0x00000000},	/* for + 1.0 */
+	{0x763b6f3d, 0x1adc4428},
+	{0x20f0630b, 0x0502909d},
+	{0x4e825578, 0x0198ce38},
+	{0x22b7cb87, 0x008da6e3},
+	{0x9b30ca03, 0x00239c79}
+};
+#define	HIPOWERop	6	/* odd poly, positive terms */
+static unsigned oddplterms[HIPOWERop][2] =
+{
+	{0xa6f67cb8, 0x94d910bd},
+	{0xa02ffab4, 0x0a43cb45},
+	{0x04265e6b, 0x02bf5655},
+	{0x0a728914, 0x00f280f7},
+	{0x6d640e01, 0x004d6556},
+	{0xf1dd2dbf, 0x000a530a}
+};
+
+
+static unsigned denomterm[2] =
+{0xfc4bd208, 0xea2e6612};
+
+
+
+/*--- poly_atan() -----------------------------------------------------------+
+ |                                                                           |
+ +---------------------------------------------------------------------------*/
+void
+poly_atan(FPU_REG * arg)
+{
+	char    recursions = 0;
+	short   exponent;
+	FPU_REG odd_poly, even_poly, pos_poly, neg_poly;
+	FPU_REG argSq;
+	long long arg_signif, argSqSq;
+
+
+#ifdef PARANOID
+	if (arg->sign != 0) {	/* Can't hack a number < 0.0 */
+		arith_invalid(arg);
+		return;
+	}			/* Need a positive number */
+#endif				/* PARANOID */
+
+	exponent = arg->exp - EXP_BIAS;
+
+	if (arg->tag == TW_Zero) {
+		/* Return 0.0 */
+		reg_move(&CONST_Z, arg);
+		return;
+	}
+	if (exponent >= -2) {
+		/* argument is in the range  [0.25 .. 1.0] */
+		if (exponent >= 0) {
+#ifdef PARANOID
+			if ((exponent == 0) &&
+			    (arg->sigl == 0) && (arg->sigh == 0x80000000))
+#endif				/* PARANOID */
+			{
+				reg_move(&CONST_PI4, arg);
+				return;
+			}
+#ifdef PARANOID
+			EXCEPTION(EX_INTERNAL | 0x104);	/* There must be a logic
+							 * error */
+#endif				/* PARANOID */
+		}
+		/* If the argument is greater than sqrt(2)-1 (=0.414213562...) */
+		/* convert the argument by an identity for atan */
+		if ((exponent >= -1) || (arg->sigh > 0xd413ccd0)) {
+			FPU_REG numerator, denom;
+
+			recursions++;
+
+			arg_signif = *(long long *) &(arg->sigl);
+			if (exponent < -1) {
+				if (shrx(&arg_signif, -1 - exponent) >= (unsigned)0x80000000)
+					arg_signif++;	/* round up */
+			}
+			*(long long *) &(numerator.sigl) = -arg_signif;
+			numerator.exp = EXP_BIAS - 1;
+			normalize(&numerator);	/* 1 - arg */
+
+			arg_signif = *(long long *) &(arg->sigl);
+			if (shrx(&arg_signif, -exponent) >= (unsigned)0x80000000)
+				arg_signif++;	/* round up */
+			*(long long *) &(denom.sigl) = arg_signif;
+			denom.sigh |= 0x80000000;	/* 1 + arg */
+
+			arg->exp = numerator.exp;
+			reg_u_div(&numerator, &denom, arg, FULL_PRECISION);
+
+			exponent = arg->exp - EXP_BIAS;
+		}
+	}
+	*(long long *) &arg_signif = *(long long *) &(arg->sigl);
+
+#ifdef PARANOID
+	/* This must always be true */
+	if (exponent >= -1) {
+		EXCEPTION(EX_INTERNAL | 0x120);	/* There must be a logic error */
+	}
+#endif				/* PARANOID */
+
+	/* shift the argument right by the required places */
+	if (shrx(&arg_signif, -1 - exponent) >= (unsigned)0x80000000)
+		arg_signif++;	/* round up */
+
+	/* Now have arg_signif with binary point at the left .1xxxxxxxx */
+	mul64(&arg_signif, &arg_signif, (long long *) (&argSq.sigl));
+	mul64((long long *) (&argSq.sigl), (long long *) (&argSq.sigl), &argSqSq);
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(pos_poly.sign) = 0;
+	pos_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial(&pos_poly.sigl, (unsigned *) &argSqSq,
+	    (unsigned short (*)[4]) oddplterms, HIPOWERop - 1);
+	mul64((long long *) (&argSq.sigl), (long long *) (&pos_poly.sigl),
+	    (long long *) (&pos_poly.sigl));
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(neg_poly.sign) = 0;
+	neg_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial(&neg_poly.sigl, (unsigned *) &argSqSq,
+	    (unsigned short (*)[4]) oddnegterms, HIPOWERon - 1);
+
+	/* Subtract the mantissas */
+	*((long long *) (&pos_poly.sigl)) -= *((long long *) (&neg_poly.sigl));
+
+	reg_move(&pos_poly, &odd_poly);
+	poly_add_1(&odd_poly);
+
+	/* The complete odd polynomial */
+	reg_u_mul(&odd_poly, arg, &odd_poly, FULL_PRECISION);
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(even_poly.sign) = 0;
+
+	mul64((long long *) (&argSq.sigl),
+	    (long long *) (&denomterm), (long long *) (&even_poly.sigl));
+
+	poly_add_1(&even_poly);
+
+	reg_div(&odd_poly, &even_poly, arg, FULL_PRECISION);
+
+	if (recursions)
+		reg_sub(&CONST_PI4, arg, arg, FULL_PRECISION);
+}
+
+
+/* The argument to this function must be polynomial() compatible,
+   i.e. have an exponent (not checked) of EXP_BIAS-1 but need not
+   be normalized.
+   This function adds 1.0 to the (assumed positive) argument. */
+void
+poly_add_1(FPU_REG * src)
+{
+/* Rounding in a consistent direction produces better results
+   for the use of this function in poly_atan. Simple truncation
+   is used here instead of round-to-nearest. */
+
+#ifdef OBSOLETE
+	char    round = (src->sigl & 3) == 3;
+#endif				/* OBSOLETE */
+
+	shrx(&src->sigl, 1);
+
+#ifdef OBSOLETE
+	if (round)
+		(*(long long *) &src->sigl)++;	/* Round to even */
+#endif				/* OBSOLETE */
+
+	src->sigh |= 0x80000000;
+
+	src->exp = EXP_BIAS;
+
+}
diff --git a/sys/gnu/i386/fpemul/poly_div.s b/sys/gnu/i386/fpemul/poly_div.s
new file mode 100644
index 0000000..d7dc316
--- /dev/null
+++ b/sys/gnu/i386/fpemul/poly_div.s
@@ -0,0 +1,131 @@
+	.file	"poly_div.S"
+/*
+ *  poly_div.S
+ *
+ * A set of functions to divide 64 bit integers by fixed numbers.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "fpu_asm.h"
+
+.text
+
+/*---------------------------------------------------------------------------*/
+	.align 2,144
+.globl _poly_div2
+_poly_div2:
+	pushl %ebp
+	movl %esp,%ebp
+
+	movl PARAM1,%ecx
+	movw (%ecx),%ax
+
+	shrl $1,4(%ecx)
+	rcrl $1,(%ecx)
+
+	testw $1,%ax
+	je poly_div2_exit
+
+	addl $1,(%ecx)
+	adcl $0,4(%ecx)
+poly_div2_exit:
+
+	leave
+	ret
+/*---------------------------------------------------------------------------*/
+	.align 2,144
+.globl _poly_div4
+_poly_div4:
+	pushl %ebp
+	movl %esp,%ebp
+
+	movl PARAM1,%ecx
+	movw (%ecx),%ax
+
+	movl 4(%ecx),%edx
+	shll $30,%edx
+
+	shrl $2,4(%ecx)
+	shrl $2,(%ecx)
+
+	orl %edx,(%ecx)
+
+	testw $2,%ax
+	je poly_div4_exit
+
+	addl $1,(%ecx)
+	adcl $0,4(%ecx)
+poly_div4_exit:
+
+	leave
+	ret
+/*---------------------------------------------------------------------------*/
+	.align 2,144
+.globl _poly_div16
+_poly_div16:
+	pushl %ebp
+	movl %esp,%ebp
+
+	movl PARAM1,%ecx
+	movw (%ecx),%ax
+
+	movl 4(%ecx),%edx
+	shll $28,%edx
+
+	shrl $4,4(%ecx)
+	shrl $4,(%ecx)
+
+	orl %edx,(%ecx)
+
+	testw $8,%ax
+	je poly_div16_exit
+
+	addl $1,(%ecx)
+	adcl $0,4(%ecx)
+poly_div16_exit:
+
+	leave
+	ret
+/*---------------------------------------------------------------------------*/
diff --git a/sys/gnu/i386/fpemul/poly_l2.c b/sys/gnu/i386/fpemul/poly_l2.c
new file mode 100644
index 0000000..fbb1ab0
--- /dev/null
+++ b/sys/gnu/i386/fpemul/poly_l2.c
@@ -0,0 +1,305 @@
+/*
+ *  poly_l2.c
+ *
+ * Compute the base 2 log of a FPU_REG, using a polynomial approximation.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include "exception.h"
+#include "reg_constant.h"
+#include "fpu_emu.h"
+#include "control_w.h"
+
+
+
+#define	HIPOWER	9
+static unsigned short lterms[HIPOWER][4] =
+{
+	/* Ideal computation with these coeffs gives about 64.6 bit rel
+	 * accuracy. */
+	{0xe177, 0xb82f, 0x7652, 0x7154},
+	{0xee0f, 0xe80f, 0x2770, 0x7b1c},
+	{0x0fc0, 0xbe87, 0xb143, 0x49dd},
+	{0x78b9, 0xdadd, 0xec54, 0x34c2},
+	{0x003a, 0x5de9, 0x628b, 0x2909},
+	{0x5588, 0xed16, 0x4abf, 0x2193},
+	{0xb461, 0x85f7, 0x347a, 0x1c6a},
+	{0x0975, 0x87b3, 0xd5bf, 0x1876},
+	{0xe85c, 0xcec9, 0x84e7, 0x187d}
+};
+
+
+
+
+/*--- poly_l2() -------------------------------------------------------------+
+ |   Base 2 logarithm by a polynomial approximation.                         |
+ +---------------------------------------------------------------------------*/
+void
+poly_l2(FPU_REG * arg, FPU_REG * result)
+{
+	short   exponent;
+	char    zero;		/* flag for an Xx == 0 */
+	unsigned short bits, shift;
+	long long Xsq;
+	FPU_REG accum, denom, num, Xx;
+
+
+	exponent = arg->exp - EXP_BIAS;
+
+	accum.tag = TW_Valid;	/* set the tags to Valid */
+
+	if (arg->sigh > (unsigned) 0xb504f334) {
+		/* This is good enough for the computation of the polynomial
+		 * sum, but actually results in a loss of precision for the
+		 * computation of Xx. This will matter only if exponent
+		 * becomes zero. */
+		exponent++;
+		accum.sign = 1;	/* sign to negative */
+		num.exp = EXP_BIAS;	/* needed to prevent errors in div
+					 * routine */
+		reg_u_div(&CONST_1, arg, &num, FULL_PRECISION);
+	} else {
+		accum.sign = 0;	/* set the sign to positive */
+		num.sigl = arg->sigl;	/* copy the mantissa */
+		num.sigh = arg->sigh;
+	}
+
+
+	/* shift num left, lose the ms bit */
+	num.sigh <<= 1;
+	if (num.sigl & 0x80000000)
+		num.sigh |= 1;
+	num.sigl <<= 1;
+
+	denom.sigl = num.sigl;
+	denom.sigh = num.sigh;
+	poly_div4((long long *) &(denom.sigl));
+	denom.sigh += 0x80000000;	/* set the msb */
+	Xx.exp = EXP_BIAS;	/* needed to prevent errors in div routine */
+	reg_u_div(&num, &denom, &Xx, FULL_PRECISION);
+
+	zero = !(Xx.sigh | Xx.sigl);
+
+	mul64((long long *) &Xx.sigl, (long long *) &Xx.sigl, &Xsq);
+	poly_div16(&Xsq);
+
+	accum.exp = -1;		/* exponent of accum */
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial((unsigned *) &accum.sigl, (unsigned *) &Xsq, lterms, HIPOWER - 1);
+
+	if (!exponent) {
+		/* If the exponent is zero, then we would lose precision by
+		 * sticking to fixed point computation here */
+		/* We need to re-compute Xx because of loss of precision. */
+		FPU_REG lXx;
+		char    sign;
+
+		sign = accum.sign;
+		accum.sign = 0;
+
+		/* make accum compatible and normalize */
+		accum.exp = EXP_BIAS + accum.exp;
+		normalize(&accum);
+
+		if (zero) {
+			reg_move(&CONST_Z, result);
+		} else {
+			/* we need to re-compute lXx to better accuracy */
+			num.tag = TW_Valid;	/* set the tags to Vaild */
+			num.sign = 0;	/* set the sign to positive */
+			num.exp = EXP_BIAS - 1;
+			if (sign) {
+				/* The argument is of the form 1-x */
+				/* Use  1-1/(1-x) = x/(1-x) */
+				*((long long *) &num.sigl) = -*((long long *) &(arg->sigl));
+				normalize(&num);
+				reg_div(&num, arg, &num, FULL_PRECISION);
+			} else {
+				normalize(&num);
+			}
+
+			denom.tag = TW_Valid;	/* set the tags to Valid */
+			denom.sign = SIGN_POS;	/* set the sign to positive */
+			denom.exp = EXP_BIAS;
+
+			reg_div(&num, &denom, &lXx, FULL_PRECISION);
+
+			reg_u_mul(&lXx, &accum, &accum, FULL_PRECISION);
+
+			reg_u_add(&lXx, &accum, result, FULL_PRECISION);
+
+			normalize(result);
+		}
+
+		result->sign = sign;
+		return;
+	}
+	mul64((long long *) &accum.sigl,
+	    (long long *) &Xx.sigl, (long long *) &accum.sigl);
+
+	*((long long *) (&accum.sigl)) += *((long long *) (&Xx.sigl));
+
+	if (Xx.sigh > accum.sigh) {
+		/* There was an overflow */
+
+		poly_div2((long long *) &accum.sigl);
+		accum.sigh |= 0x80000000;
+		accum.exp++;
+	}
+	/* When we add the exponent to the accum result later, we will require
+	 * that their signs are the same. Here we ensure that this is so. */
+	if (exponent && ((exponent < 0) ^ (accum.sign))) {
+		/* signs are different */
+
+		accum.sign = !accum.sign;
+
+		/* An exceptional case is when accum is zero */
+		if (accum.sigl | accum.sigh) {
+			/* find 1-accum */
+			/* Shift to get exponent == 0 */
+			if (accum.exp < 0) {
+				poly_div2((long long *) &accum.sigl);
+				accum.exp++;
+			}
+			/* Just negate, but throw away the sign */
+			*((long long *) &(accum.sigl)) = -*((long long *) &(accum.sigl));
+			if (exponent < 0)
+				exponent++;
+			else
+				exponent--;
+		}
+	}
+	shift = exponent >= 0 ? exponent : -exponent;
+	bits = 0;
+	if (shift) {
+		if (accum.exp) {
+			accum.exp++;
+			poly_div2((long long *) &accum.sigl);
+		}
+		while (shift) {
+			poly_div2((long long *) &accum.sigl);
+			if (shift & 1)
+				accum.sigh |= 0x80000000;
+			shift >>= 1;
+			bits++;
+		}
+	}
+	/* Convert to 64 bit signed-compatible */
+	accum.exp += bits + EXP_BIAS - 1;
+
+	reg_move(&accum, result);
+	normalize(result);
+
+	return;
+}
+
+
+/*--- poly_l2p1() -----------------------------------------------------------+
+ |   Base 2 logarithm by a polynomial approximation.                         |
+ |   log2(x+1)                                                               |
+ +---------------------------------------------------------------------------*/
+int
+poly_l2p1(FPU_REG * arg, FPU_REG * result)
+{
+	char    sign = 0;
+	long long Xsq;
+	FPU_REG arg_pl1, denom, accum, local_arg, poly_arg;
+
+
+	sign = arg->sign;
+
+	reg_add(arg, &CONST_1, &arg_pl1, FULL_PRECISION);
+
+	if ((arg_pl1.sign) | (arg_pl1.tag)) {	/* We need a valid positive
+						 * number! */
+		return 1;
+	}
+	reg_add(&CONST_1, &arg_pl1, &denom, FULL_PRECISION);
+	reg_div(arg, &denom, &local_arg, FULL_PRECISION);
+	local_arg.sign = 0;	/* Make the sign positive */
+
+	/* Now we need to check that  |local_arg| is less than 3-2*sqrt(2) =
+	 * 0.17157.. = .0xafb0ccc0 * 2^-2 */
+
+	if (local_arg.exp >= EXP_BIAS - 3) {
+		if ((local_arg.exp > EXP_BIAS - 3) ||
+		    (local_arg.sigh > (unsigned) 0xafb0ccc0)) {
+			/* The argument is large */
+			poly_l2(&arg_pl1, result);
+			return 0;
+		}
+	}
+	/* Make a copy of local_arg */
+	reg_move(&local_arg, &poly_arg);
+
+	/* Get poly_arg bits aligned as required */
+	shrx((unsigned *) &(poly_arg.sigl), -(poly_arg.exp - EXP_BIAS + 3));
+
+	mul64((long long *) &(poly_arg.sigl), (long long *) &(poly_arg.sigl), &Xsq);
+	poly_div16(&Xsq);
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial(&(accum.sigl), (unsigned *) &Xsq, lterms, HIPOWER - 1);
+
+	accum.tag = TW_Valid;	/* set the tags to Valid */
+	accum.sign = SIGN_POS;	/* and make accum positive */
+
+	/* make accum compatible and normalize */
+	accum.exp = EXP_BIAS - 1;
+	normalize(&accum);
+
+	reg_u_mul(&local_arg, &accum, &accum, FULL_PRECISION);
+
+	reg_u_add(&local_arg, &accum, result, FULL_PRECISION);
+
+	/* Multiply the result by 2 */
+	result->exp++;
+
+	result->sign = sign;
+
+	return 0;
+}
diff --git a/sys/gnu/i386/fpemul/poly_mul64.s b/sys/gnu/i386/fpemul/poly_mul64.s
new file mode 100644
index 0000000..8f1fbbd
--- /dev/null
+++ b/sys/gnu/i386/fpemul/poly_mul64.s
@@ -0,0 +1,111 @@
+/*
+ *  poly_mul64.S
+ *
+ * Multiply two 64 bit integers.
+ *
+ * Call from C as:
+ *   void mul64(long long *a, long long *b, long long *result)
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include "fpu_asm.h"
+
+.text
+	.align 2,144
+.globl _mul64
+_mul64:
+	pushl %ebp
+	movl %esp,%ebp
+	subl $16,%esp
+	pushl %esi
+	pushl %ebx
+
+	movl PARAM1,%esi
+	movl PARAM2,%ecx
+	movl PARAM3,%ebx
+
+	xor %eax,%eax
+	movl %eax,-4(%ebp)
+	movl %eax,-8(%ebp)
+
+	movl (%esi),%eax
+	mull (%ecx)
+	movl %eax,-16(%ebp)	/* Not used */
+	movl %edx,-12(%ebp)
+
+	movl (%esi),%eax
+	mull 4(%ecx)
+	addl %eax,-12(%ebp)
+	adcl %edx,-8(%ebp)
+	adcl $0,-4(%ebp)
+
+	movl 4(%esi),%eax
+	mull (%ecx)
+	addl %eax,-12(%ebp)
+	adcl %edx,-8(%ebp)
+	adcl $0,-4(%ebp)
+
+	movl 4(%esi),%eax
+	mull 4(%ecx)
+	addl %eax,-8(%ebp)
+	adcl %edx,-4(%ebp)
+
+	testb $128,-9(%ebp)
+	je L_no_round
+
+	addl $1,-8(%ebp)
+	adcl $0,-4(%ebp)
+
+L_no_round:
+	movl -8(%ebp),%esi
+	movl %esi,(%ebx)
+	movl -4(%ebp),%esi
+	movl %esi,4(%ebx)
+
+	popl %ebx
+	popl %esi
+	leave
+	ret
diff --git a/sys/gnu/i386/fpemul/poly_sin.c b/sys/gnu/i386/fpemul/poly_sin.c
new file mode 100644
index 0000000..6c5d04a
--- /dev/null
+++ b/sys/gnu/i386/fpemul/poly_sin.c
@@ -0,0 +1,179 @@
+/*
+ *  poly_sin.c
+ *
+ *  Computation of an approximation of the sin function by a polynomial
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include "exception.h"
+#include "reg_constant.h"
+#include "fpu_emu.h"
+#include "control_w.h"
+
+
+#define	HIPOWER	5
+static unsigned short lterms[HIPOWER][4] =
+{
+	{0x846a, 0x42d1, 0xb544, 0x921f},
+	{0xe110, 0x75aa, 0xbc67, 0x1466},
+	{0x503d, 0xa43f, 0x83c1, 0x000a},
+	{0x8f9d, 0x7a19, 0x00f4, 0x0000},
+	{0xda03, 0x06aa, 0x0000, 0x0000},
+};
+
+static unsigned short negterms[HIPOWER][4] =
+{
+	{0x95ed, 0x2df2, 0xe731, 0xa55d},
+	{0xd159, 0xe62b, 0xd2cc, 0x0132},
+	{0x6342, 0xe9fb, 0x3c60, 0x0000},
+	{0x6256, 0xdf5a, 0x0002, 0x0000},
+	{0xf279, 0x000b, 0x0000, 0x0000},
+};
+
+
+/*--- poly_sine() -----------------------------------------------------------+
+ |                                                                           |
+ +---------------------------------------------------------------------------*/
+void
+poly_sine(FPU_REG * arg, FPU_REG * result)
+{
+	short   exponent;
+	FPU_REG Xx, Xx2, Xx4, accum, negaccum;
+
+
+	exponent = arg->exp - EXP_BIAS;
+
+	if (arg->tag == TW_Zero) {
+		/* Return 0.0 */
+		reg_move(&CONST_Z, result);
+		return;
+	}
+#ifdef PARANOID
+	if (arg->sign != 0) {	/* Can't hack a number < 0.0 */
+		EXCEPTION(EX_Invalid);
+		reg_move(&CONST_QNaN, result);
+		return;
+	}
+	if (exponent >= 0) {	/* Can't hack a number > 1.0 */
+		if ((exponent == 0) && (arg->sigl == 0) && (arg->sigh == 0x80000000)) {
+			reg_move(&CONST_1, result);
+			return;
+		}
+		EXCEPTION(EX_Invalid);
+		reg_move(&CONST_QNaN, result);
+		return;
+	}
+#endif				/* PARANOID */
+
+	Xx.sigl = arg->sigl;
+	Xx.sigh = arg->sigh;
+	if (exponent < -1) {
+		/* shift the argument right by the required places */
+		if (shrx(&(Xx.sigl), -1 - exponent) >= (unsigned)0x80000000)
+			(*((long long *) (&(Xx.sigl))))++;	/* round up */
+	}
+	mul64((long long *) &(Xx.sigl), (long long *) &(Xx.sigl),
+	    (long long *) &(Xx2.sigl));
+	mul64((long long *) &(Xx2.sigl), (long long *) &(Xx2.sigl),
+	    (long long *) &(Xx4.sigl));
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(accum.sign) = 0;
+	accum.exp = 0;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial(&(accum.sigl), &(Xx4.sigl), lterms, HIPOWER - 1);
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(negaccum.sign) = 0;
+	negaccum.exp = 0;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial(&(negaccum.sigl), &(Xx4.sigl), negterms, HIPOWER - 1);
+	mul64((long long *) &(Xx2.sigl), (long long *) &(negaccum.sigl),
+	    (long long *) &(negaccum.sigl));
+
+	/* Subtract the mantissas */
+	*((long long *) (&(accum.sigl))) -= *((long long *) (&(negaccum.sigl)));
+
+	/* Convert to 64 bit signed-compatible */
+	accum.exp = EXP_BIAS - 1 + accum.exp;
+
+	*(short *) &(result->sign) = *(short *) &(accum.sign);
+	result->exp = accum.exp;
+	result->sigl = accum.sigl;
+	result->sigh = accum.sigh;
+
+	normalize(result);
+
+	reg_mul(result, arg, result, FULL_PRECISION);
+	reg_u_add(result, arg, result, FULL_PRECISION);
+
+	/* A small overflow may be possible... but an illegal result. */
+	if (result->exp >= EXP_BIAS) {
+		if ((result->exp > EXP_BIAS)	/* Larger or equal 2.0 */
+		    ||(result->sigl > 1)	/* Larger than 1.0+msb */
+		    ||(result->sigh != 0x80000000)	/* Much > 1.0 */
+		    ) {
+#ifdef DEBUGGING
+			RE_ENTRANT_CHECK_OFF
+			    printk("\nEXP=%d, MS=%08x, LS=%08x\n", result->exp,
+			    result->sigh, result->sigl);
+			RE_ENTRANT_CHECK_ON
+#endif				/* DEBUGGING */
+			    EXCEPTION(EX_INTERNAL | 0x103);
+		}
+#ifdef DEBUGGING
+		RE_ENTRANT_CHECK_OFF
+		    printk("\n***CORRECTING ILLEGAL RESULT*** in poly_sin() computation\n");
+		printk("EXP=%d, MS=%08x, LS=%08x\n", result->exp,
+		    result->sigh, result->sigl);
+		RE_ENTRANT_CHECK_ON
+#endif				/* DEBUGGING */
+
+		    result->sigl = 0;	/* Truncate the result to 1.00 */
+	}
+}
diff --git a/sys/gnu/i386/fpemul/poly_tan.c b/sys/gnu/i386/fpemul/poly_tan.c
new file mode 100644
index 0000000..b11630a
--- /dev/null
+++ b/sys/gnu/i386/fpemul/poly_tan.c
@@ -0,0 +1,216 @@
+/*
+ *  poly_tan.c
+ *
+ * Compute the tan of a FPU_REG, using a polynomial approximation.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "exception.h"
+#include "reg_constant.h"
+#include "fpu_emu.h"
+#include "control_w.h"
+
+
+#define	HIPOWERop	3	/* odd poly, positive terms */
+static unsigned short oddplterms[HIPOWERop][4] =
+{
+	{0x846a, 0x42d1, 0xb544, 0x921f},
+	{0x6fb2, 0x0215, 0x95c0, 0x099c},
+	{0xfce6, 0x0cc8, 0x1c9a, 0x0000}
+};
+#define	HIPOWERon	2	/* odd poly, negative terms */
+static unsigned short oddnegterms[HIPOWERon][4] =
+{
+	{0x6906, 0xe205, 0x25c8, 0x8838},
+	{0x1dd7, 0x3fe3, 0x944e, 0x002c}
+};
+#define	HIPOWERep	2	/* even poly, positive terms */
+static unsigned short evenplterms[HIPOWERep][4] =
+{
+	{0xdb8f, 0x3761, 0x1432, 0x2acf},
+	{0x16eb, 0x13c1, 0x3099, 0x0003}
+};
+#define	HIPOWERen	2	/* even poly, negative terms */
+static unsigned short evennegterms[HIPOWERen][4] =
+{
+	{0x3a7c, 0xe4c5, 0x7f87, 0x2945},
+	{0x572b, 0x664c, 0xc543, 0x018c}
+};
+
+
+/*--- poly_tan() ------------------------------------------------------------+
+ |                                                                           |
+ +---------------------------------------------------------------------------*/
+void
+poly_tan(FPU_REG * arg, FPU_REG * y_reg)
+{
+	char    invert = 0;
+	short   exponent;
+	FPU_REG odd_poly, even_poly, pos_poly, neg_poly;
+	FPU_REG argSq;
+	long long arg_signif, argSqSq;
+
+
+	exponent = arg->exp - EXP_BIAS;
+
+	if (arg->tag == TW_Zero) {
+		/* Return 0.0 */
+		reg_move(&CONST_Z, y_reg);
+		return;
+	}
+	if (exponent >= -1) {
+		/* argument is in the range  [0.5 .. 1.0] */
+		if (exponent >= 0) {
+#ifdef PARANOID
+			if ((exponent == 0) &&
+			    (arg->sigl == 0) && (arg->sigh == 0x80000000))
+#endif				/* PARANOID */
+			{
+				arith_overflow(y_reg);
+				return;
+			}
+#ifdef PARANOID
+			EXCEPTION(EX_INTERNAL | 0x104);	/* There must be a logic
+							 * error */
+			return;
+#endif				/* PARANOID */
+		}
+		/* The argument is in the range  [0.5 .. 1.0) */
+		/* Convert the argument to a number in the range  (0.0 .. 0.5] */
+		*((long long *) (&arg->sigl)) = -*((long long *) (&arg->sigl));
+		normalize(arg);	/* Needed later */
+		exponent = arg->exp - EXP_BIAS;
+		invert = 1;
+	}
+#ifdef PARANOID
+	if (arg->sign != 0) {	/* Can't hack a number < 0.0 */
+		arith_invalid(y_reg);
+		return;
+	}			/* Need a positive number */
+#endif				/* PARANOID */
+
+	*(long long *) &arg_signif = *(long long *) &(arg->sigl);
+	if (exponent < -1) {
+		/* shift the argument right by the required places */
+		if (shrx(&arg_signif, -1 - exponent) >= (unsigned)0x80000000)
+			arg_signif++;	/* round up */
+	}
+	mul64(&arg_signif, &arg_signif, (long long *) (&argSq.sigl));
+	mul64((long long *) (&argSq.sigl), (long long *) (&argSq.sigl), &argSqSq);
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(pos_poly.sign) = 0;
+	pos_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial(&pos_poly.sigl, (unsigned *) &argSqSq, oddplterms, HIPOWERop - 1);
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(neg_poly.sign) = 0;
+	neg_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial(&neg_poly.sigl, (unsigned *) &argSqSq, oddnegterms, HIPOWERon - 1);
+	mul64((long long *) (&argSq.sigl), (long long *) (&neg_poly.sigl),
+	    (long long *) (&neg_poly.sigl));
+
+	/* Subtract the mantissas */
+	*((long long *) (&pos_poly.sigl)) -= *((long long *) (&neg_poly.sigl));
+
+	/* Convert to 64 bit signed-compatible */
+	pos_poly.exp -= 1;
+
+	reg_move(&pos_poly, &odd_poly);
+	normalize(&odd_poly);
+
+	reg_mul(&odd_poly, arg, &odd_poly, FULL_PRECISION);
+	reg_u_add(&odd_poly, arg, &odd_poly, FULL_PRECISION);	/* This is just the odd
+								 * polynomial */
+
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(pos_poly.sign) = 0;
+	pos_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial(&pos_poly.sigl, (unsigned *) &argSqSq, evenplterms, HIPOWERep - 1);
+	mul64((long long *) (&argSq.sigl),
+	    (long long *) (&pos_poly.sigl), (long long *) (&pos_poly.sigl));
+
+	/* will be a valid positive nr with expon = 0 */
+	*(short *) &(neg_poly.sign) = 0;
+	neg_poly.exp = EXP_BIAS;
+
+	/* Do the basic fixed point polynomial evaluation */
+	polynomial(&neg_poly.sigl, (unsigned *) &argSqSq, evennegterms, HIPOWERen - 1);
+
+	/* Subtract the mantissas */
+	*((long long *) (&neg_poly.sigl)) -= *((long long *) (&pos_poly.sigl));
+	/* and multiply by argSq */
+
+	/* Convert argSq to a valid reg number */
+	*(short *) &(argSq.sign) = 0;
+	argSq.exp = EXP_BIAS - 1;
+	normalize(&argSq);
+
+	/* Convert to 64 bit signed-compatible */
+	neg_poly.exp -= 1;
+
+	reg_move(&neg_poly, &even_poly);
+	normalize(&even_poly);
+
+	reg_mul(&even_poly, &argSq, &even_poly, FULL_PRECISION);
+	reg_add(&even_poly, &argSq, &even_poly, FULL_PRECISION);
+	reg_sub(&CONST_1, &even_poly, &even_poly, FULL_PRECISION);	/* This is just the even
+									 * polynomial */
+
+	/* Now ready to copy the results */
+	if (invert) {
+		reg_div(&even_poly, &odd_poly, y_reg, FULL_PRECISION);
+	} else {
+		reg_div(&odd_poly, &even_poly, y_reg, FULL_PRECISION);
+	}
+
+}
diff --git a/sys/gnu/i386/fpemul/polynomial.s b/sys/gnu/i386/fpemul/polynomial.s
new file mode 100644
index 0000000..c5a2596
--- /dev/null
+++ b/sys/gnu/i386/fpemul/polynomial.s
@@ -0,0 +1,179 @@
+/*
+ *  polynomial.S
+ *
+ * Fixed point arithmetic polynomial evaluation.
+ *
+ * Call from C as:
+ *   void polynomial(unsigned accum[], unsigned x[], unsigned terms[][2],
+ *                   int n)
+ *
+ * Computes:
+ * terms[0] + (terms[1] + (terms[2] + ... + (terms[n-1]*x)*x)*x)*x) ... )*x
+ * The result is returned in accum.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+	.file	"fpolynom.s"
+
+#include "fpu_asm.h"
+
+
+/*	#define	EXTRA_PRECISE*/
+
+#define	TERM_SIZE	$8
+
+
+.text
+	.align 2,144
+.globl _polynomial
+_polynomial:
+	pushl	%ebp
+	movl	%esp,%ebp
+	subl	$32,%esp
+	pushl	%esi
+	pushl	%edi
+	pushl	%ebx
+
+	movl	PARAM1,%esi		/* accum */
+	movl	PARAM2,%edi		/* x */
+	movl	PARAM3,%ebx		/* terms */
+	movl	PARAM4,%ecx		/* n */
+
+	movl	TERM_SIZE,%eax
+	mull	%ecx
+	movl	%eax,%ecx
+
+	movl	4(%ebx,%ecx,1),%edx	/* terms[n] */
+	movl	%edx,-20(%ebp)
+	movl	(%ebx,%ecx,1),%edx	/* terms[n] */
+	movl	%edx,-24(%ebp)		
+	xor	%eax,%eax
+	movl	%eax,-28(%ebp)
+
+	subl	TERM_SIZE,%ecx
+	js	L_accum_done
+
+L_accum_loop:
+	xor	%eax,%eax
+	movl	%eax,-4(%ebp)
+	movl	%eax,-8(%ebp)
+
+#ifdef EXTRA_PRECISE
+	movl	-28(%ebp),%eax
+	mull	4(%edi)			/* x ms long */
+	movl	%edx,-12(%ebp)
+#endif EXTRA_PRECISE
+
+	movl	-24(%ebp),%eax
+	mull	(%edi)			/* x ls long */
+/*	movl	%eax,-16(%ebp)	*/	/* Not needed */
+	addl	%edx,-12(%ebp)
+	adcl	$0,-8(%ebp)
+
+	movl	-24(%ebp),%eax
+	mull	4(%edi)			/* x ms long */
+	addl	%eax,-12(%ebp)
+	adcl	%edx,-8(%ebp)
+	adcl	$0,-4(%ebp)
+
+	movl	-20(%ebp),%eax
+	mull	(%edi)
+	addl	%eax,-12(%ebp)
+	adcl	%edx,-8(%ebp)
+	adcl	$0,-4(%ebp)
+
+	movl	-20(%ebp),%eax
+	mull	4(%edi)
+	addl	%eax,-8(%ebp)
+	adcl	%edx,-4(%ebp)
+
+/* Now add the next term */
+	movl	(%ebx,%ecx,1),%eax
+	addl	%eax,-8(%ebp)
+	movl	4(%ebx,%ecx,1),%eax
+	adcl	%eax,-4(%ebp)
+
+/* And put into the second register */
+	movl	-4(%ebp),%eax
+	movl	%eax,-20(%ebp)
+	movl	-8(%ebp),%eax
+	movl	%eax,-24(%ebp)
+
+#ifdef EXTRA_PRECISE
+	movl	-12(%ebp),%eax
+	movl	%eax,-28(%ebp)
+#else
+	testb	$128,-25(%ebp)
+	je	L_no_poly_round
+
+	addl	$1,-24(%ebp)
+	adcl	$0,-20(%ebp)
+L_no_poly_round:
+#endif EXTRA_PRECISE
+
+	subl	TERM_SIZE,%ecx
+	jns	L_accum_loop
+
+L_accum_done:
+#ifdef EXTRA_PRECISE
+/* And round the result */
+	testb	$128,-25(%ebp)
+	je	L_poly_done
+
+	addl	$1,-24(%ebp)
+	adcl	$0,-20(%ebp)
+#endif EXTRA_PRECISE
+
+L_poly_done:
+	movl	-24(%ebp),%eax
+	movl	%eax,(%esi)
+	movl	-20(%ebp),%eax
+	movl	%eax,4(%esi)
+
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+	leave
+	ret
diff --git a/sys/gnu/i386/fpemul/reg_add_sub.c b/sys/gnu/i386/fpemul/reg_add_sub.c
new file mode 100644
index 0000000..cc2a727
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_add_sub.c
@@ -0,0 +1,290 @@
+/*
+ *  reg_add_sub.c
+ *
+ * Functions to add or subtract two registers and put the result in a third.
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*---------------------------------------------------------------------------+
+ | For each function, the destination may be any FPU_REG, including one of   |
+ | the source FPU_REGs.                                                      |
+ +---------------------------------------------------------------------------*/
+
+#include "exception.h"
+#include "reg_constant.h"
+#include "fpu_emu.h"
+#include "control_w.h"
+#include "fpu_system.h"
+
+
+void
+reg_add(FPU_REG * a, FPU_REG * b, FPU_REG * dest, int control_w)
+{
+	int     diff;
+
+	if (!(a->tag | b->tag)) {
+		/* Both registers are valid */
+		if (!(a->sign ^ b->sign)) {
+			/* signs are the same */
+			reg_u_add(a, b, dest, control_w);
+			dest->sign = a->sign;
+			return;
+		}
+		/* The signs are different, so do a subtraction */
+		diff = a->exp - b->exp;
+		if (!diff) {
+			diff = a->sigh - b->sigh;	/* Works only if ms bits
+							 * are identical */
+			if (!diff) {
+				diff = a->sigl > b->sigl;
+				if (!diff)
+					diff = -(a->sigl < b->sigl);
+			}
+		}
+		if (diff > 0) {
+			reg_u_sub(a, b, dest, control_w);
+			dest->sign = a->sign;
+		} else
+			if (diff == 0) {
+				reg_move(&CONST_Z, dest);
+				/* sign depends upon rounding mode */
+				dest->sign = ((control_w & CW_RC) != RC_DOWN)
+				    ? SIGN_POS : SIGN_NEG;
+			} else {
+				reg_u_sub(b, a, dest, control_w);
+				dest->sign = b->sign;
+			}
+		return;
+	} else {
+		if ((a->tag == TW_NaN) || (b->tag == TW_NaN)) {
+			real_2op_NaN(a, b, dest);
+			return;
+		} else
+			if (a->tag == TW_Zero) {
+				if (b->tag == TW_Zero) {
+					char    different_signs = a->sign ^ b->sign;
+					/* Both are zero, result will be zero. */
+					reg_move(a, dest);
+					if (different_signs) {
+						/* Signs are different. */
+						/* Sign of answer depends upon
+						 * rounding mode. */
+						dest->sign = ((control_w & CW_RC) != RC_DOWN)
+						    ? SIGN_POS : SIGN_NEG;
+					}
+				} else {
+#ifdef DENORM_OPERAND
+					if ((b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
+					    denormal_operand())
+						return;
+#endif				/* DENORM_OPERAND */
+					reg_move(b, dest);
+				}
+				return;
+			} else
+				if (b->tag == TW_Zero) {
+#ifdef DENORM_OPERAND
+					if ((a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&
+					    denormal_operand())
+						return;
+#endif				/* DENORM_OPERAND */
+					reg_move(a, dest);
+					return;
+				} else
+					if (a->tag == TW_Infinity) {
+						if (b->tag != TW_Infinity) {
+#ifdef DENORM_OPERAND
+							if ((b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
+							    denormal_operand())
+								return;
+#endif				/* DENORM_OPERAND */
+							reg_move(a, dest);
+							return;
+						}
+						if (a->sign == b->sign) {
+							/* They are both + or
+							 * - infinity */
+							reg_move(a, dest);
+							return;
+						}
+						arith_invalid(dest);	/* Infinity-Infinity is
+									 * undefined. */
+						return;
+					} else
+						if (b->tag == TW_Infinity) {
+#ifdef DENORM_OPERAND
+							if ((a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&
+							    denormal_operand())
+								return;
+#endif				/* DENORM_OPERAND */
+							reg_move(b, dest);
+							return;
+						}
+	}
+#ifdef PARANOID
+	EXCEPTION(EX_INTERNAL | 0x101);
+#endif
+}
+
+
+/* Subtract b from a.  (a-b) -> dest */
+void
+reg_sub(FPU_REG * a, FPU_REG * b, FPU_REG * dest, int control_w)
+{
+	int     diff;
+
+	if (!(a->tag | b->tag)) {
+		/* Both registers are valid */
+		diff = a->exp - b->exp;
+		if (!diff) {
+			diff = a->sigh - b->sigh;	/* Works only if ms bits
+							 * are identical */
+			if (!diff) {
+				diff = a->sigl > b->sigl;
+				if (!diff)
+					diff = -(a->sigl < b->sigl);
+			}
+		}
+		switch (a->sign * 2 + b->sign) {
+		case 0:	/* P - P */
+		case 3:	/* N - N */
+			if (diff > 0) {
+				reg_u_sub(a, b, dest, control_w);
+				dest->sign = a->sign;
+			} else
+				if (diff == 0) {
+#ifdef DENORM_OPERAND
+					if ((b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
+					    denormal_operand())
+						return;
+#endif				/* DENORM_OPERAND */
+					reg_move(&CONST_Z, dest);
+					/* sign depends upon rounding mode */
+					dest->sign = ((control_w & CW_RC) != RC_DOWN)
+					    ? SIGN_POS : SIGN_NEG;
+				} else {
+					reg_u_sub(b, a, dest, control_w);
+					dest->sign = a->sign ^ SIGN_POS ^ SIGN_NEG;
+				}
+			return;
+		case 1:	/* P - N */
+			reg_u_add(a, b, dest, control_w);
+			dest->sign = SIGN_POS;
+			return;
+		case 2:	/* N - P */
+			reg_u_add(a, b, dest, control_w);
+			dest->sign = SIGN_NEG;
+			return;
+		}
+	} else {
+		if ((a->tag == TW_NaN) || (b->tag == TW_NaN)) {
+			real_2op_NaN(a, b, dest);
+			return;
+		} else
+			if (b->tag == TW_Zero) {
+				if (a->tag == TW_Zero) {
+					char    same_signs = !(a->sign ^ b->sign);
+					/* Both are zero, result will be zero. */
+					reg_move(a, dest);	/* Answer for different
+								 * signs. */
+					if (same_signs) {
+						/* Sign depends upon rounding
+						 * mode */
+						dest->sign = ((control_w & CW_RC) != RC_DOWN)
+						    ? SIGN_POS : SIGN_NEG;
+					}
+				} else {
+#ifdef DENORM_OPERAND
+					if ((a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&
+					    denormal_operand())
+						return;
+#endif				/* DENORM_OPERAND */
+					reg_move(a, dest);
+				}
+				return;
+			} else
+				if (a->tag == TW_Zero) {
+#ifdef DENORM_OPERAND
+					if ((b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
+					    denormal_operand())
+						return;
+#endif				/* DENORM_OPERAND */
+					reg_move(b, dest);
+					dest->sign ^= SIGN_POS ^ SIGN_NEG;
+					return;
+				} else
+					if (a->tag == TW_Infinity) {
+						if (b->tag != TW_Infinity) {
+#ifdef DENORM_OPERAND
+							if ((b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
+							    denormal_operand())
+								return;
+#endif				/* DENORM_OPERAND */
+							reg_move(a, dest);
+							return;
+						}
+						/* Both args are Infinity */
+						if (a->sign == b->sign) {
+							arith_invalid(dest);	/* Infinity-Infinity is
+										 * undefined. */
+							return;
+						}
+						reg_move(a, dest);
+						return;
+					} else
+						if (b->tag == TW_Infinity) {
+#ifdef DENORM_OPERAND
+							if ((a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&
+							    denormal_operand())
+								return;
+#endif				/* DENORM_OPERAND */
+							reg_move(b, dest);
+							dest->sign ^= SIGN_POS ^ SIGN_NEG;
+							return;
+						}
+	}
+#ifdef PARANOID
+	EXCEPTION(EX_INTERNAL | 0x110);
+#endif
+}
diff --git a/sys/gnu/i386/fpemul/reg_compare.c b/sys/gnu/i386/fpemul/reg_compare.c
new file mode 100644
index 0000000..f543311
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_compare.c
@@ -0,0 +1,371 @@
+/*
+ *  reg_compare.c
+ *
+ * Compare two floating point registers
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*---------------------------------------------------------------------------+
+ | compare() is the core FPU_REG comparison function                         |
+ +---------------------------------------------------------------------------*/
+#include "param.h"
+#include "proc.h"
+#include "systm.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "exception.h"
+#include "control_w.h"
+#include "status_w.h"
+
+
+int
+compare(FPU_REG * b)
+{
+	int     diff;
+
+	if (FPU_st0_ptr->tag | b->tag) {
+		if (FPU_st0_ptr->tag == TW_Zero) {
+			if (b->tag == TW_Zero)
+				return COMP_A_eq_B;
+			if (b->tag == TW_Valid) {
+#ifdef DENORM_OPERAND
+				if ((b->exp <= EXP_UNDER) && (denormal_operand()))
+					return COMP_Denormal;
+#endif				/* DENORM_OPERAND */
+				return (b->sign == SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B;
+			}
+		} else
+			if (b->tag == TW_Zero) {
+				if (FPU_st0_ptr->tag == TW_Valid) {
+#ifdef DENORM_OPERAND
+					if ((FPU_st0_ptr->exp <= EXP_UNDER) && (denormal_operand()))
+						return COMP_Denormal;
+#endif				/* DENORM_OPERAND */
+					return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B;
+				}
+			}
+		if (FPU_st0_ptr->tag == TW_Infinity) {
+			if ((b->tag == TW_Valid) || (b->tag == TW_Zero)) {
+#ifdef DENORM_OPERAND
+				if ((b->tag == TW_Valid) && (b->exp <= EXP_UNDER)
+				    && (denormal_operand()))
+					return COMP_Denormal;
+#endif				/* DENORM_OPERAND */
+				return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B;
+			} else
+				if (b->tag == TW_Infinity) {
+					/* The 80486 book says that infinities
+					 * can be equal! */
+					return (FPU_st0_ptr->sign == b->sign) ? COMP_A_eq_B :
+					    ((FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B);
+				}
+			/* Fall through to the NaN code */
+		} else
+			if (b->tag == TW_Infinity) {
+				if ((FPU_st0_ptr->tag == TW_Valid) || (FPU_st0_ptr->tag == TW_Zero)) {
+#ifdef DENORM_OPERAND
+					if ((FPU_st0_ptr->tag == TW_Valid)
+					    && (FPU_st0_ptr->exp <= EXP_UNDER)
+					    && (denormal_operand()))
+						return COMP_Denormal;
+#endif				/* DENORM_OPERAND */
+					return (b->sign == SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B;
+				}
+				/* Fall through to the NaN code */
+			}
+		/* The only possibility now should be that one of the
+		 * arguments is a NaN */
+		if ((FPU_st0_ptr->tag == TW_NaN) || (b->tag == TW_NaN)) {
+			if (((FPU_st0_ptr->tag == TW_NaN) && !(FPU_st0_ptr->sigh & 0x40000000))
+			    || ((b->tag == TW_NaN) && !(b->sigh & 0x40000000)))
+				/* At least one arg is a signaling NaN */
+				return COMP_No_Comp | COMP_SNaN | COMP_NaN;
+			else
+				/* Neither is a signaling NaN */
+				return COMP_No_Comp | COMP_NaN;
+		}
+		EXCEPTION(EX_Invalid);
+	}
+#ifdef PARANOID
+	if (!(FPU_st0_ptr->sigh & 0x80000000))
+		EXCEPTION(EX_Invalid);
+	if (!(b->sigh & 0x80000000))
+		EXCEPTION(EX_Invalid);
+#endif				/* PARANOID */
+
+#ifdef DENORM_OPERAND
+	if (((FPU_st0_ptr->exp <= EXP_UNDER) ||
+		(b->exp <= EXP_UNDER)) && (denormal_operand()))
+		return COMP_Denormal;
+#endif				/* DENORM_OPERAND */
+
+	if (FPU_st0_ptr->sign != b->sign)
+		return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B;
+
+	diff = FPU_st0_ptr->exp - b->exp;
+	if (diff == 0) {
+		diff = FPU_st0_ptr->sigh - b->sigh;	/* Works only if ms bits
+							 * are identical */
+		if (diff == 0) {
+			diff = FPU_st0_ptr->sigl > b->sigl;
+			if (diff == 0)
+				diff = -(FPU_st0_ptr->sigl < b->sigl);
+		}
+	}
+	if (diff > 0)
+		return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_gt_B : COMP_A_lt_B;
+	if (diff < 0)
+		return (FPU_st0_ptr->sign == SIGN_POS) ? COMP_A_lt_B : COMP_A_gt_B;
+	return COMP_A_eq_B;
+
+}
+
+
+/* This function requires that st(0) is not empty */
+int
+compare_st_data(void)
+{
+	int     f, c;
+
+	c = compare(&FPU_loaded_data);
+
+	if (c & (COMP_NaN | COMP_Denormal)) {
+		if (c & COMP_NaN) {
+			EXCEPTION(EX_Invalid);
+			f = SW_C3 | SW_C2 | SW_C0;
+		} else {
+			/* One of the operands is a de-normal */
+			return 0;
+		}
+	} else
+		switch (c) {
+		case COMP_A_lt_B:
+			f = SW_C0;
+			break;
+		case COMP_A_eq_B:
+			f = SW_C3;
+			break;
+		case COMP_A_gt_B:
+			f = 0;
+			break;
+		case COMP_No_Comp:
+			f = SW_C3 | SW_C2 | SW_C0;
+			break;
+#ifdef PARANOID
+		default:
+			EXCEPTION(EX_INTERNAL | 0x121);
+			f = SW_C3 | SW_C2 | SW_C0;
+			break;
+#endif				/* PARANOID */
+		}
+	setcc(f);
+	return 1;
+}
+
+
+static int
+compare_st_st(int nr)
+{
+	int     f, c;
+
+	if (!NOT_EMPTY_0 || !NOT_EMPTY(nr)) {
+		setcc(SW_C3 | SW_C2 | SW_C0);
+		/* Stack fault */
+		EXCEPTION(EX_StackUnder);
+		return control_word & CW_Invalid;
+	}
+	c = compare(&st(nr));
+	if (c & (COMP_NaN | COMP_Denormal)) {
+		if (c & COMP_NaN) {
+			setcc(SW_C3 | SW_C2 | SW_C0);
+			EXCEPTION(EX_Invalid);
+			return control_word & CW_Invalid;
+		} else {
+			/* One of the operands is a de-normal */
+			return control_word & CW_Denormal;
+		}
+	} else
+		switch (c) {
+		case COMP_A_lt_B:
+			f = SW_C0;
+			break;
+		case COMP_A_eq_B:
+			f = SW_C3;
+			break;
+		case COMP_A_gt_B:
+			f = 0;
+			break;
+		case COMP_No_Comp:
+			f = SW_C3 | SW_C2 | SW_C0;
+			break;
+#ifdef PARANOID
+		default:
+			EXCEPTION(EX_INTERNAL | 0x122);
+			f = SW_C3 | SW_C2 | SW_C0;
+			break;
+#endif				/* PARANOID */
+		}
+	setcc(f);
+	return 1;
+}
+
+
+static int
+compare_u_st_st(int nr)
+{
+	int     f, c;
+
+	if (!NOT_EMPTY_0 || !NOT_EMPTY(nr)) {
+		setcc(SW_C3 | SW_C2 | SW_C0);
+		/* Stack fault */
+		EXCEPTION(EX_StackUnder);
+		return control_word & CW_Invalid;
+	}
+	c = compare(&st(nr));
+	if (c & (COMP_NaN | COMP_Denormal)) {
+		if (c & COMP_NaN) {
+			setcc(SW_C3 | SW_C2 | SW_C0);
+			if (c & COMP_SNaN) {	/* This is the only difference
+						 * between un-ordered and
+						 * ordinary comparisons */
+				EXCEPTION(EX_Invalid);
+				return control_word & CW_Invalid;
+			}
+			return 1;
+		} else {
+			/* One of the operands is a de-normal */
+			return control_word & CW_Denormal;
+		}
+	} else
+		switch (c) {
+		case COMP_A_lt_B:
+			f = SW_C0;
+			break;
+		case COMP_A_eq_B:
+			f = SW_C3;
+			break;
+		case COMP_A_gt_B:
+			f = 0;
+			break;
+		case COMP_No_Comp:
+			f = SW_C3 | SW_C2 | SW_C0;
+			break;
+#ifdef PARANOID
+		default:
+			EXCEPTION(EX_INTERNAL | 0x123);
+			f = SW_C3 | SW_C2 | SW_C0;
+			break;
+#endif				/* PARANOID */
+		}
+	setcc(f);
+	return 1;
+}
+/*---------------------------------------------------------------------------*/
+
+void
+fcom_st()
+{
+	/* fcom st(i) */
+	compare_st_st(FPU_rm);
+}
+
+
+void
+fcompst()
+{
+	/* fcomp st(i) */
+	if (compare_st_st(FPU_rm))
+		pop();
+}
+
+
+void
+fcompp()
+{
+	/* fcompp */
+	if (FPU_rm != 1)
+		return Un_impl();
+	if (compare_st_st(1)) {
+		pop();
+		FPU_st0_ptr = &st(0);
+		pop();
+	}
+}
+
+
+void
+fucom_()
+{
+	/* fucom st(i) */
+	compare_u_st_st(FPU_rm);
+
+}
+
+
+void
+fucomp()
+{
+	/* fucomp st(i) */
+	if (compare_u_st_st(FPU_rm))
+		pop();
+}
+
+
+void
+fucompp()
+{
+	/* fucompp */
+	if (FPU_rm == 1) {
+		if (compare_u_st_st(1)) {
+			pop();
+			FPU_st0_ptr = &st(0);
+			pop();
+		}
+	} else
+		Un_impl();
+}
diff --git a/sys/gnu/i386/fpemul/reg_constant.c b/sys/gnu/i386/fpemul/reg_constant.c
new file mode 100644
index 0000000..d779862
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_constant.c
@@ -0,0 +1,159 @@
+/*
+ *  reg_constant.c
+ *
+ * All of the constant FPU_REGs
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include "param.h"
+#include "proc.h"
+#include "systm.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "status_w.h"
+#include "reg_constant.h"
+
+
+FPU_REG CONST_1 = {SIGN_POS, TW_Valid, EXP_BIAS,
+0x00000000, 0x80000000};
+FPU_REG CONST_2 = {SIGN_POS, TW_Valid, EXP_BIAS + 1,
+0x00000000, 0x80000000};
+FPU_REG CONST_HALF = {SIGN_POS, TW_Valid, EXP_BIAS - 1,
+0x00000000, 0x80000000};
+FPU_REG CONST_L2T = {SIGN_POS, TW_Valid, EXP_BIAS + 1,
+0xcd1b8afe, 0xd49a784b};
+FPU_REG CONST_L2E = {SIGN_POS, TW_Valid, EXP_BIAS,
+0x5c17f0bc, 0xb8aa3b29};
+FPU_REG CONST_PI = {SIGN_POS, TW_Valid, EXP_BIAS + 1,
+0x2168c235, 0xc90fdaa2};
+FPU_REG CONST_PI2 = {SIGN_POS, TW_Valid, EXP_BIAS,
+0x2168c235, 0xc90fdaa2};
+FPU_REG CONST_PI4 = {SIGN_POS, TW_Valid, EXP_BIAS - 1,
+0x2168c235, 0xc90fdaa2};
+FPU_REG CONST_LG2 = {SIGN_POS, TW_Valid, EXP_BIAS - 2,
+0xfbcff799, 0x9a209a84};
+FPU_REG CONST_LN2 = {SIGN_POS, TW_Valid, EXP_BIAS - 1,
+0xd1cf79ac, 0xb17217f7};
+/* Only the sign (and tag) is used in internal zeroes */
+FPU_REG CONST_Z = {SIGN_POS, TW_Zero, 0, 0x0, 0x0};
+/* Only the sign and significand (and tag) are used in internal NaNs */
+/* The 80486 never generates one of these
+FPU_REG CONST_SNAN = { SIGN_POS, TW_NaN, EXP_OVER, 0x00000001, 0x80000000 };
+ */
+/* This is the real indefinite QNaN */
+FPU_REG CONST_QNaN = {SIGN_NEG, TW_NaN, EXP_OVER, 0x00000000, 0xC0000000};
+/* Only the sign (and tag) is used in internal infinities */
+FPU_REG CONST_INF = {SIGN_POS, TW_Infinity, EXP_OVER, 0x00000000, 0x80000000};
+
+
+
+static void
+fld_const(FPU_REG * c)
+{
+	FPU_REG *st_new_ptr;
+
+	if (STACK_OVERFLOW) {
+		stack_overflow();
+		return;
+	}
+	push();
+	reg_move(c, FPU_st0_ptr);
+	status_word &= ~SW_C1;
+}
+
+
+static void
+fld1(void)
+{
+	fld_const(&CONST_1);
+}
+
+static void
+fldl2t(void)
+{
+	fld_const(&CONST_L2T);
+}
+
+static void
+fldl2e(void)
+{
+	fld_const(&CONST_L2E);
+}
+
+static void
+fldpi(void)
+{
+	fld_const(&CONST_PI);
+}
+
+static void
+fldlg2(void)
+{
+	fld_const(&CONST_LG2);
+}
+
+static void
+fldln2(void)
+{
+	fld_const(&CONST_LN2);
+}
+
+static void
+fldz(void)
+{
+	fld_const(&CONST_Z);
+}
+
+static FUNC constants_table[] = {
+	fld1, fldl2t, fldl2e, fldpi, fldlg2, fldln2, fldz, Un_impl
+};
+
+void
+fconst(void)
+{
+	(constants_table[FPU_rm]) ();
+}
diff --git a/sys/gnu/i386/fpemul/reg_constant.h b/sys/gnu/i386/fpemul/reg_constant.h
new file mode 100644
index 0000000..a5181f9
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_constant.h
@@ -0,0 +1,69 @@
+/*
+ *  reg_constant.h
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _REG_CONSTANT_H_
+#define _REG_CONSTANT_H_
+
+#include "fpu_emu.h"
+
+extern FPU_REG CONST_1;
+extern FPU_REG CONST_2;
+extern FPU_REG CONST_HALF;
+extern FPU_REG CONST_L2T;
+extern FPU_REG CONST_L2E;
+extern FPU_REG CONST_PI;
+extern FPU_REG CONST_PI2;
+extern FPU_REG CONST_PI4;
+extern FPU_REG CONST_LG2;
+extern FPU_REG CONST_LN2;
+extern FPU_REG CONST_Z;
+extern FPU_REG CONST_PINF;
+extern FPU_REG CONST_INF;
+extern FPU_REG CONST_MINF;
+extern FPU_REG CONST_QNaN;
+
+#endif				/* _REG_CONSTANT_H_ */
diff --git a/sys/gnu/i386/fpemul/reg_div.s b/sys/gnu/i386/fpemul/reg_div.s
new file mode 100644
index 0000000..0abdc05
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_div.s
@@ -0,0 +1,282 @@
+	.file	"reg_div.S"
+/*
+ *  reg_div.S
+ *
+ * Divide one FPU_REG by another and put the result in a destination FPU_REG.
+ *
+ * Call from C as:
+ *   void reg_div(FPU_REG *a, FPU_REG *b, FPU_REG *dest,
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *                                    unsigned int control_word)
+ */
+
+#include "exception.h"
+#include "fpu_asm.h"
+#include "control_w.h"
+
+.text
+	.align 2
+
+.globl	_reg_div
+_reg_div:
+	pushl	%ebp
+	movl	%esp,%ebp
+
+	pushl	%esi
+	pushl	%edi
+	pushl	%ebx
+
+	movl	PARAM1,%esi
+	movl	PARAM2,%ebx
+	movl	PARAM3,%edi
+
+	movb	TAG(%esi),%al
+	orb	TAG(%ebx),%al
+
+	jne	L_div_special		/* Not (both numbers TW_Valid) */
+
+#ifdef DENORM_OPERAND
+/* Check for denormals */
+	cmpl	EXP_UNDER,EXP(%esi)
+	jg	xL_arg1_not_denormal
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xL_arg1_not_denormal:
+	cmpl	EXP_UNDER,EXP(%ebx)
+	jg	xL_arg2_not_denormal
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xL_arg2_not_denormal:
+#endif DENORM_OPERAND
+
+/* Both arguments are TW_Valid */
+	movb	TW_Valid,TAG(%edi)
+
+	movb	SIGN(%esi),%cl
+	cmpb	%cl,SIGN(%ebx)
+	setne	(%edi)	   /* Set the sign, requires SIGN_NEG=1, SIGN_POS=0 */
+
+	movl	EXP(%esi),%edx
+	movl	EXP(%ebx),%eax
+	subl	%eax,%edx
+	addl	EXP_BIAS,%edx
+	movl	%edx,EXP(%edi)
+
+	jmp	_divide_kernel
+
+
+/*-----------------------------------------------------------------------*/
+L_div_special:
+	cmpb	TW_NaN,TAG(%esi)	/* A NaN with anything to give NaN */
+	je	L_arg1_NaN
+
+	cmpb	TW_NaN,TAG(%ebx)	/* A NaN with anything to give NaN */
+	jne	L_no_NaN_arg
+
+/*  Operations on NaNs */
+L_arg1_NaN:
+L_arg2_NaN:
+	pushl	%edi			/* Destination */
+	pushl	%ebx
+	pushl	%esi
+	call	_real_2op_NaN
+	jmp	LDiv_exit
+
+/* Invalid operations */
+L_zero_zero:
+L_inf_inf:
+	pushl	%edi			/* Destination */
+	call	_arith_invalid		/* 0/0 or Infinity/Infinity */
+	jmp	LDiv_exit
+
+L_no_NaN_arg:
+	cmpb	TW_Infinity,TAG(%esi)
+	jne	L_arg1_not_inf
+
+	cmpb	TW_Infinity,TAG(%ebx)
+	je	L_inf_inf		/* invalid operation */
+
+	cmpb	TW_Valid,TAG(%ebx)
+	je	L_inf_valid
+
+#ifdef PARANOID
+	/* arg2 must be zero or valid */
+	cmpb	TW_Zero,TAG(%ebx)
+	ja	L_unknown_tags
+#endif PARANOID
+
+	/* Note that p16-9 says that infinity/0 returns infinity */
+	jmp	L_copy_arg1		/* Answer is Inf */
+
+L_inf_valid:
+#ifdef DENORM_OPERAND
+	cmpl	EXP_UNDER,EXP(%ebx)
+	jg	L_copy_arg1		/* Answer is Inf */
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+#endif DENORM_OPERAND
+
+	jmp	L_copy_arg1		/* Answer is Inf */
+
+L_arg1_not_inf:
+	cmpb	TW_Zero,TAG(%ebx)	/* Priority to div-by-zero error */
+	jne	L_arg2_not_zero
+
+	cmpb	TW_Zero,TAG(%esi)
+	je	L_zero_zero		/* invalid operation */
+
+#ifdef PARANOID
+	/* arg1 must be valid */
+	cmpb	TW_Valid,TAG(%esi)
+	ja	L_unknown_tags
+#endif PARANOID
+
+/* Division by zero error */
+	pushl	%edi			/* destination */
+	movb	SIGN(%esi),%al
+	xorb	SIGN(%ebx),%al
+	pushl	%eax			/* lower 8 bits have the sign */
+	call	_divide_by_zero
+	jmp	LDiv_exit
+
+L_arg2_not_zero:
+	cmpb	TW_Infinity,TAG(%ebx)
+	jne	L_arg2_not_inf
+
+#ifdef DENORM_OPERAND
+	cmpb	TW_Valid,TAG(%esi)
+	jne	L_return_zero
+
+	cmpl	EXP_UNDER,EXP(%esi)
+	jg	L_return_zero		/* Answer is zero */
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+#endif DENORM_OPERAND
+
+	jmp	L_return_zero		/* Answer is zero */
+
+L_arg2_not_inf:
+
+#ifdef PARANOID
+	cmpb	TW_Zero,TAG(%esi)
+	jne	L_unknown_tags
+#endif PARANOID
+
+	/* arg1 is zero, arg2 is not Infinity or a NaN */
+
+#ifdef DENORM_OPERAND
+	cmpl	EXP_UNDER,EXP(%ebx)
+	jg	L_copy_arg1		/* Answer is zero */
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+#endif DENORM_OPERAND
+
+L_copy_arg1:
+	movb	TAG(%esi),%ax
+	movb	%ax,TAG(%edi)
+	movl	EXP(%esi),%eax
+	movl	%eax,EXP(%edi)
+	movl	SIGL(%esi),%eax
+	movl	%eax,SIGL(%edi)
+	movl	SIGH(%esi),%eax
+	movl	%eax,SIGH(%edi)
+
+	movb	SIGN(%esi),%cl
+	cmpb	%cl,SIGN(%ebx)
+	jne	LDiv_negative_result
+
+	movb	SIGN_POS,SIGN(%edi)
+	jmp	LDiv_exit
+
+LDiv_set_result_sign:
+	movb	SIGN(%esi),%cl
+	cmpb	%cl,SIGN(%edi)
+	jne	LDiv_negative_result
+
+	movb	SIGN_POS,SIGN(%ebx)
+	jmp	LDiv_exit
+
+LDiv_negative_result:
+	movb	SIGN_NEG,SIGN(%edi)
+
+LDiv_exit:
+	leal	-12(%ebp),%esp
+
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+	leave
+	ret
+
+
+L_return_zero:
+	movb	TW_Zero,TAG(%edi)
+	jmp	LDiv_set_result_sign
+
+#ifdef PARANOID
+L_unknown_tags:
+	push	EX_INTERNAL | 0x208
+	call	EXCEPTION
+
+	/* Generate a NaN for unknown tags */
+	movl	_CONST_QNaN,%eax
+	movl	%eax,(%edi)
+	movl	_CONST_QNaN+4,%eax
+	movl	%eax,SIGL(%edi)
+	movl	_CONST_QNaN+8,%eax
+	movl	%eax,SIGH(%edi)
+	jmp	LDiv_exit
+#endif PARANOID
diff --git a/sys/gnu/i386/fpemul/reg_ld_str.c b/sys/gnu/i386/fpemul/reg_ld_str.c
new file mode 100644
index 0000000..a0c5568
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_ld_str.c
@@ -0,0 +1,1374 @@
+/*
+ *  reg_ld_str.c
+ *
+ * All of the functions which transfer data between user memory and FPU_REGs.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+/*---------------------------------------------------------------------------+
+ | Note:                                                                     |
+ |    The file contains code which accesses user memory.                     |
+ |    Emulator static data may change when user memory is accessed, due to   |
+ |    other processes using the emulator while swapping is in progress.      |
+ +---------------------------------------------------------------------------*/
+#include "param.h"
+#include "proc.h"
+#include "systm.h"
+#include "machine/cpu.h"
+#include "machine/pcb.h"
+
+#include "fpu_emu.h"
+#include "fpu_system.h"
+#include "exception.h"
+#include "reg_constant.h"
+#include "control_w.h"
+#include "status_w.h"
+
+
+#define EXTENDED_Emax 0x3fff	/* largest valid exponent */
+#define EXTENDED_Ebias 0x3fff
+#define EXTENDED_Emin (-0x3ffe)	/* smallest valid exponent */
+
+#define DOUBLE_Emax 1023	/* largest valid exponent */
+#define DOUBLE_Ebias 1023
+#define DOUBLE_Emin (-1022)	/* smallest valid exponent */
+
+#define SINGLE_Emax 127		/* largest valid exponent */
+#define SINGLE_Ebias 127
+#define SINGLE_Emin (-126)	/* smallest valid exponent */
+
+#define LOST_UP    (EX_Precision | SW_C1)
+#define LOST_DOWN  EX_Precision
+
+FPU_REG FPU_loaded_data;
+
+
+/* Get a long double from user memory */
+void
+reg_load_extended(void)
+{
+	long double *s = (long double *) FPU_data_address;
+	unsigned long sigl, sigh, exp;
+
+	REENTRANT_CHECK(OFF);
+	/* Use temporary variables here because FPU_loaded data is static and
+	 * hence re-entrancy problems can arise */
+	sigl = fuword((unsigned long *) s);
+	sigh = fuword(1 + (unsigned long *) s);
+	exp = fuword(4 + (unsigned short *) s);
+	REENTRANT_CHECK(ON);
+
+	FPU_loaded_data.sigl = sigl;
+	FPU_loaded_data.sigh = sigh;
+	FPU_loaded_data.exp = exp;
+
+	if (FPU_loaded_data.exp & 0x8000)
+		FPU_loaded_data.sign = SIGN_NEG;
+	else
+		FPU_loaded_data.sign = SIGN_POS;
+	if ((FPU_loaded_data.exp &= 0x7fff) == 0) {
+		if (!(FPU_loaded_data.sigl | FPU_loaded_data.sigh)) {
+			FPU_loaded_data.tag = TW_Zero;
+			return;
+		}
+		/* The number is a de-normal or pseudodenormal. */
+		/* The 80486 doesn't regard pseudodenormals as denormals here. */
+		if (!(FPU_loaded_data.sigh & 0x80000000))
+			EXCEPTION(EX_Denormal);
+		FPU_loaded_data.exp++;
+
+		/* The default behaviour will now take care of it. */
+	} else
+		if (FPU_loaded_data.exp == 0x7fff) {
+			FPU_loaded_data.exp = EXTENDED_Emax;
+			if ((FPU_loaded_data.sigh == 0x80000000)
+			    && (FPU_loaded_data.sigl == 0)) {
+				FPU_loaded_data.tag = TW_Infinity;
+				return;
+			} else
+				if (!(FPU_loaded_data.sigh & 0x80000000)) {
+					/* Unsupported NaN data type */
+					EXCEPTION(EX_Invalid);
+					FPU_loaded_data.tag = TW_NaN;
+					return;
+				}
+			FPU_loaded_data.tag = TW_NaN;
+			return;
+		}
+	FPU_loaded_data.exp = (FPU_loaded_data.exp & 0x7fff) - EXTENDED_Ebias
+	    + EXP_BIAS;
+	FPU_loaded_data.tag = TW_Valid;
+
+	if (!(sigh & 0x80000000)) {
+		/* Unsupported data type */
+		EXCEPTION(EX_Invalid);
+		normalize_nuo(&FPU_loaded_data);
+	}
+}
+
+
+/* Get a double from user memory */
+void
+reg_load_double(void)
+{
+	double *dfloat = (double *) FPU_data_address;
+	int     exp;
+	unsigned m64, l64;
+
+	REENTRANT_CHECK(OFF);
+	m64 = fuword(1 + (unsigned long *) dfloat);
+	l64 = fuword((unsigned long *) dfloat);
+	REENTRANT_CHECK(ON);
+
+	if (m64 & 0x80000000)
+		FPU_loaded_data.sign = SIGN_NEG;
+	else
+		FPU_loaded_data.sign = SIGN_POS;
+	exp = ((m64 & 0x7ff00000) >> 20) - DOUBLE_Ebias;
+	m64 &= 0xfffff;
+	if (exp > DOUBLE_Emax) {
+		/* Infinity or NaN */
+		if ((m64 == 0) && (l64 == 0)) {
+			/* +- infinity */
+			FPU_loaded_data.exp = EXTENDED_Emax;
+			FPU_loaded_data.tag = TW_Infinity;
+			return;
+		} else {
+			/* Must be a signaling or quiet NaN */
+			FPU_loaded_data.exp = EXTENDED_Emax;
+			FPU_loaded_data.tag = TW_NaN;
+			FPU_loaded_data.sigh = (m64 << 11) | 0x80000000;
+			FPU_loaded_data.sigh |= l64 >> 21;
+			FPU_loaded_data.sigl = l64 << 11;
+			return;
+		}
+	} else
+		if (exp < DOUBLE_Emin) {
+			/* Zero or de-normal */
+			if ((m64 == 0) && (l64 == 0)) {
+				/* Zero */
+				int     c = FPU_loaded_data.sign;
+				reg_move(&CONST_Z, &FPU_loaded_data);
+				FPU_loaded_data.sign = c;
+				return;
+			} else {
+				/* De-normal */
+				EXCEPTION(EX_Denormal);
+				FPU_loaded_data.exp = DOUBLE_Emin + EXP_BIAS;
+				FPU_loaded_data.tag = TW_Valid;
+				FPU_loaded_data.sigh = m64 << 11;
+				FPU_loaded_data.sigh |= l64 >> 21;
+				FPU_loaded_data.sigl = l64 << 11;
+				normalize_nuo(&FPU_loaded_data);
+				return;
+			}
+		} else {
+			FPU_loaded_data.exp = exp + EXP_BIAS;
+			FPU_loaded_data.tag = TW_Valid;
+			FPU_loaded_data.sigh = (m64 << 11) | 0x80000000;
+			FPU_loaded_data.sigh |= l64 >> 21;
+			FPU_loaded_data.sigl = l64 << 11;
+
+			return;
+		}
+}
+
+
+/* Get a float from user memory */
+void
+reg_load_single(void)
+{
+	float  *single = (float *) FPU_data_address;
+	unsigned m32;
+	int     exp;
+
+	REENTRANT_CHECK(OFF);
+	m32 = fuword((unsigned long *) single);
+	REENTRANT_CHECK(ON);
+
+	if (m32 & 0x80000000)
+		FPU_loaded_data.sign = SIGN_NEG;
+	else
+		FPU_loaded_data.sign = SIGN_POS;
+	if (!(m32 & 0x7fffffff)) {
+		/* Zero */
+		int     c = FPU_loaded_data.sign;
+		reg_move(&CONST_Z, &FPU_loaded_data);
+		FPU_loaded_data.sign = c;
+		return;
+	}
+	exp = ((m32 & 0x7f800000) >> 23) - SINGLE_Ebias;
+	m32 = (m32 & 0x7fffff) << 8;
+	if (exp < SINGLE_Emin) {
+		/* De-normals */
+		EXCEPTION(EX_Denormal);
+		FPU_loaded_data.exp = SINGLE_Emin + EXP_BIAS;
+		FPU_loaded_data.tag = TW_Valid;
+		FPU_loaded_data.sigh = m32;
+		FPU_loaded_data.sigl = 0;
+		normalize_nuo(&FPU_loaded_data);
+		return;
+	} else
+		if (exp > SINGLE_Emax) {
+			/* Infinity or NaN */
+			if (m32 == 0) {
+				/* +- infinity */
+				FPU_loaded_data.exp = EXTENDED_Emax;
+				FPU_loaded_data.tag = TW_Infinity;
+				return;
+			} else {
+				/* Must be a signaling or quiet NaN */
+				FPU_loaded_data.exp = EXTENDED_Emax;
+				FPU_loaded_data.tag = TW_NaN;
+				FPU_loaded_data.sigh = m32 | 0x80000000;
+				FPU_loaded_data.sigl = 0;
+				return;
+			}
+		} else {
+			FPU_loaded_data.exp = exp + EXP_BIAS;
+			FPU_loaded_data.sigh = m32 | 0x80000000;
+			FPU_loaded_data.sigl = 0;
+			FPU_loaded_data.tag = TW_Valid;
+		}
+}
+
+
+/* Get a long long from user memory */
+void
+reg_load_int64(void)
+{
+	long long *_s = (long long *) FPU_data_address;
+	int     e;
+	long long s;
+
+	REENTRANT_CHECK(OFF);
+	((unsigned long *) &s)[0] = fuword((unsigned long *) _s);
+	((unsigned long *) &s)[1] = fuword(1 + (unsigned long *) _s);
+	REENTRANT_CHECK(ON);
+
+	if (s == 0) {
+		reg_move(&CONST_Z, &FPU_loaded_data);
+		return;
+	}
+	if (s > 0)
+		FPU_loaded_data.sign = SIGN_POS;
+	else {
+		s = -s;
+		FPU_loaded_data.sign = SIGN_NEG;
+	}
+
+	e = EXP_BIAS + 63;
+	*((long long *) &FPU_loaded_data.sigl) = s;
+	FPU_loaded_data.exp = e;
+	FPU_loaded_data.tag = TW_Valid;
+	normalize_nuo(&FPU_loaded_data);
+}
+
+
+/* Get a long from user memory */
+void
+reg_load_int32(void)
+{
+	long   *_s = (long *) FPU_data_address;
+	long    s;
+	int     e;
+
+	REENTRANT_CHECK(OFF);
+	s = (long) fuword((unsigned long *) _s);
+	REENTRANT_CHECK(ON);
+
+	if (s == 0) {
+		reg_move(&CONST_Z, &FPU_loaded_data);
+		return;
+	}
+	if (s > 0)
+		FPU_loaded_data.sign = SIGN_POS;
+	else {
+		s = -s;
+		FPU_loaded_data.sign = SIGN_NEG;
+	}
+
+	e = EXP_BIAS + 31;
+	FPU_loaded_data.sigh = s;
+	FPU_loaded_data.sigl = 0;
+	FPU_loaded_data.exp = e;
+	FPU_loaded_data.tag = TW_Valid;
+	normalize_nuo(&FPU_loaded_data);
+}
+
+
+/* Get a short from user memory */
+void
+reg_load_int16(void)
+{
+	short  *_s = (short *) FPU_data_address;
+	int     s, e;
+
+	REENTRANT_CHECK(OFF);
+	/* Cast as short to get the sign extended. */
+	s = (short) fuword((unsigned short *) _s);
+	REENTRANT_CHECK(ON);
+
+	if (s == 0) {
+		reg_move(&CONST_Z, &FPU_loaded_data);
+		return;
+	}
+	if (s > 0)
+		FPU_loaded_data.sign = SIGN_POS;
+	else {
+		s = -s;
+		FPU_loaded_data.sign = SIGN_NEG;
+	}
+
+	e = EXP_BIAS + 15;
+	FPU_loaded_data.sigh = s << 16;
+
+	FPU_loaded_data.sigl = 0;
+	FPU_loaded_data.exp = e;
+	FPU_loaded_data.tag = TW_Valid;
+	normalize_nuo(&FPU_loaded_data);
+}
+
+
+/* Get a packed bcd array from user memory */
+void
+reg_load_bcd(void)
+{
+	char   *s = (char *) FPU_data_address;
+	int     pos;
+	unsigned char bcd;
+	long long l = 0;
+
+	for (pos = 8; pos >= 0; pos--) {
+		l *= 10;
+		REENTRANT_CHECK(OFF);
+		bcd = (unsigned char) fubyte((unsigned char *) s + pos);
+		REENTRANT_CHECK(ON);
+		l += bcd >> 4;
+		l *= 10;
+		l += bcd & 0x0f;
+	}
+
+	/* Finish all access to user memory before putting stuff into the
+	 * static FPU_loaded_data */
+	REENTRANT_CHECK(OFF);
+	FPU_loaded_data.sign =
+	    ((unsigned char) fubyte((unsigned char *) s + 9)) & 0x80 ?
+	    SIGN_NEG : SIGN_POS;
+	REENTRANT_CHECK(ON);
+
+	if (l == 0) {
+		char    sign = FPU_loaded_data.sign;
+		reg_move(&CONST_Z, &FPU_loaded_data);
+		FPU_loaded_data.sign = sign;
+	} else {
+		*((long long *) &FPU_loaded_data.sigl) = l;
+		FPU_loaded_data.exp = EXP_BIAS + 63;
+		FPU_loaded_data.tag = TW_Valid;
+		normalize_nuo(&FPU_loaded_data);
+	}
+}
+/*===========================================================================*/
+
+/* Put a long double into user memory */
+int
+reg_store_extended(void)
+{
+	long double *d = (long double *) FPU_data_address;
+	long    e = FPU_st0_ptr->exp - EXP_BIAS + EXTENDED_Ebias;
+	unsigned short sign = FPU_st0_ptr->sign * 0x8000;
+	unsigned long ls, ms;
+
+
+	if (FPU_st0_tag == TW_Valid) {
+		if (e >= 0x7fff) {
+			EXCEPTION(EX_Overflow);	/* Overflow */
+			/* This is a special case: see sec 16.2.5.1 of the
+			 * 80486 book */
+			if (control_word & EX_Overflow) {
+				/* Overflow to infinity */
+				ls = 0;
+				ms = 0x80000000;
+				e = 0x7fff;
+			} else
+				return 0;
+		} else
+			if (e <= 0) {
+				if (e > -63) {
+					/* Correctly format the de-normal */
+					int     precision_loss;
+					FPU_REG tmp;
+
+					EXCEPTION(EX_Denormal);
+					reg_move(FPU_st0_ptr, &tmp);
+					tmp.exp += -EXTENDED_Emin + 63;	/* largest exp to be 62 */
+					if ((precision_loss = round_to_int(&tmp))) {
+						EXCEPTION(EX_Underflow | precision_loss);
+						/* This is a special case: see
+						 * sec 16.2.5.1 of the 80486
+						 * book */
+						if (!(control_word & EX_Underflow))
+							return 0;
+					}
+					e = 0;
+					ls = tmp.sigl;
+					ms = tmp.sigh;
+				} else {
+					/* ****** ??? This should not be
+					 * possible */
+					EXCEPTION(EX_Underflow);	/* Underflow */
+					/* This is a special case: see sec
+					 * 16.2.5.1 of the 80486 book */
+					if (control_word & EX_Underflow) {
+						/* Underflow to zero */
+						ls = 0;
+						ms = 0;
+						e = FPU_st0_ptr->sign == SIGN_POS ? 0x7fff : 0xffff;
+					} else
+						return 0;
+				}
+			} else {
+				ls = FPU_st0_ptr->sigl;
+				ms = FPU_st0_ptr->sigh;
+			}
+	} else
+		if (FPU_st0_tag == TW_Zero) {
+			ls = ms = 0;
+			e = 0;
+		} else
+			if (FPU_st0_tag == TW_Infinity) {
+				ls = 0;
+				ms = 0x80000000;
+				e = 0x7fff;
+			} else
+				if (FPU_st0_tag == TW_NaN) {
+					ls = FPU_st0_ptr->sigl;
+					ms = FPU_st0_ptr->sigh;
+					e = 0x7fff;
+				} else
+					if (FPU_st0_tag == TW_Empty) {
+						/* Empty register (stack
+						 * underflow) */
+						EXCEPTION(EX_StackUnder);
+						if (control_word & EX_Invalid) {
+							/* The masked response */
+							/* Put out the QNaN
+							 * indefinite */
+							ls = 0;
+							ms = 0xc0000000;
+							e = 0xffff;
+						} else
+							return 0;
+					} else {
+						/* We don't use TW_Denormal
+						 * yet ... perhaps never! */
+						EXCEPTION(EX_Invalid);
+						/* Store a NaN */
+						e = 0x7fff;
+						ls = 1;
+						ms = 0x80000000;
+					}
+	REENTRANT_CHECK(OFF);
+/*	    verify_area(VERIFY_WRITE, d, 10); */
+	suword((unsigned long *) d, ls);
+	suword(1 + (unsigned long *) d, ms);
+	suword(4 + (short *) d, (unsigned short) e | sign);
+	REENTRANT_CHECK(ON);
+
+	return 1;
+
+}
+
+
+/* Put a double into user memory */
+int
+reg_store_double(void)
+{
+	double *dfloat = (double *) FPU_data_address;
+	unsigned long l[2];
+	if (FPU_st0_tag == TW_Valid) {
+		int     exp;
+		FPU_REG tmp;
+
+		reg_move(FPU_st0_ptr, &tmp);
+		exp = tmp.exp - EXP_BIAS;
+
+		if (exp < DOUBLE_Emin) {	/* It may be a denormal */
+			/* Make a de-normal */
+			int     precision_loss;
+
+			if (exp <= -EXTENDED_Ebias)
+				EXCEPTION(EX_Denormal);
+
+			tmp.exp += -DOUBLE_Emin + 52;	/* largest exp to be 51 */
+
+			if ((precision_loss = round_to_int(&tmp))) {
+#ifdef PECULIAR_486
+				/* Did it round to a non-denormal ? */
+				/* This behaviour might be regarded as
+				 * peculiar, it appears that the 80486 rounds
+				 * to the dest precision, then converts to
+				 * decide underflow. */
+				if ((tmp.sigh == 0x00100000) && (tmp.sigl == 0) &&
+				    (FPU_st0_ptr->sigl & 0x000007ff))
+					EXCEPTION(precision_loss);
+				else
+#endif				/* PECULIAR_486 */
+				{
+					EXCEPTION(EX_Underflow | precision_loss);
+					/* This is a special case: see sec
+					 * 16.2.5.1 of the 80486 book */
+					if (!(control_word & EX_Underflow))
+						return 0;
+				}
+			}
+			l[0] = tmp.sigl;
+			l[1] = tmp.sigh;
+		} else {
+			if (tmp.sigl & 0x000007ff) {
+				unsigned long increment = 0;	/* avoid gcc warnings */
+
+				switch (control_word & CW_RC) {
+				case RC_RND:
+					/* Rounding can get a little messy.. */
+					increment = ((tmp.sigl & 0x7ff) > 0x400) |	/* nearest */
+					    ((tmp.sigl & 0xc00) == 0xc00);	/* odd -> even */
+					break;
+				case RC_DOWN:	/* towards -infinity */
+					increment = (tmp.sign == SIGN_POS) ? 0 : tmp.sigl & 0x7ff;
+					break;
+				case RC_UP:	/* towards +infinity */
+					increment = (tmp.sign == SIGN_POS) ? tmp.sigl & 0x7ff : 0;
+					break;
+				case RC_CHOP:
+					increment = 0;
+					break;
+				}
+
+				/* Truncate the mantissa */
+				tmp.sigl &= 0xfffff800;
+
+				if (increment) {
+					set_precision_flag_up();
+
+					if (tmp.sigl >= 0xfffff800) {
+						/* the sigl part overflows */
+						if (tmp.sigh == 0xffffffff) {
+							/* The sigh part
+							 * overflows */
+							tmp.sigh = 0x80000000;
+							exp++;
+							if (exp >= EXP_OVER)
+								goto overflow;
+						} else {
+							tmp.sigh++;
+						}
+						tmp.sigl = 0x00000000;
+					} else {
+						/* We only need to increment
+						 * sigl */
+						tmp.sigl += 0x00000800;
+					}
+				} else
+					set_precision_flag_down();
+			}
+			l[0] = (tmp.sigl >> 11) | (tmp.sigh << 21);
+			l[1] = ((tmp.sigh >> 11) & 0xfffff);
+
+			if (exp > DOUBLE_Emax) {
+		overflow:
+				EXCEPTION(EX_Overflow);
+				/* This is a special case: see sec 16.2.5.1 of
+				 * the 80486 book */
+				if (control_word & EX_Overflow) {
+					/* Overflow to infinity */
+					l[0] = 0x00000000;	/* Set to */
+					l[1] = 0x7ff00000;	/* + INF */
+				} else
+					return 0;
+			} else {
+				/* Add the exponent */
+				l[1] |= (((exp + DOUBLE_Ebias) & 0x7ff) << 20);
+			}
+		}
+	} else
+		if (FPU_st0_tag == TW_Zero) {
+			/* Number is zero */
+			l[0] = 0;
+			l[1] = 0;
+		} else
+			if (FPU_st0_tag == TW_Infinity) {
+				l[0] = 0;
+				l[1] = 0x7ff00000;
+			} else
+				if (FPU_st0_tag == TW_NaN) {
+					/* See if we can get a valid NaN from
+					 * the FPU_REG */
+					l[0] = (FPU_st0_ptr->sigl >> 11) | (FPU_st0_ptr->sigh << 21);
+					l[1] = ((FPU_st0_ptr->sigh >> 11) & 0xfffff);
+					if (!(l[0] | l[1])) {
+						/* This case does not seem to
+						 * be handled by the 80486
+						 * specs */
+						EXCEPTION(EX_Invalid);
+						/* Make the quiet NaN "real
+						 * indefinite" */
+						goto put_indefinite;
+					}
+					l[1] |= 0x7ff00000;
+				} else
+					if (FPU_st0_tag == TW_Empty) {
+						/* Empty register (stack
+						 * underflow) */
+						EXCEPTION(EX_StackUnder);
+						if (control_word & EX_Invalid) {
+							/* The masked response */
+							/* Put out the QNaN
+							 * indefinite */
+					put_indefinite:
+							REENTRANT_CHECK(OFF);
+							/* verify_area(VERIFY_W
+							 * RITE, (void *)
+							 * dfloat, 8); */
+							suword((unsigned long *) dfloat, 0);
+							suword(1 + (unsigned long *) dfloat, 0xfff80000);
+							REENTRANT_CHECK(ON);
+							return 1;
+						} else
+							return 0;
+					}
+#if 0				/* TW_Denormal is not used yet, and probably
+				 * won't be */
+					else
+						if (FPU_st0_tag == TW_Denormal) {
+							/* Extended real ->
+							 * double real will
+							 * always underflow */
+							l[0] = l[1] = 0;
+							EXCEPTION(EX_Underflow);
+						}
+#endif
+	if (FPU_st0_ptr->sign)
+		l[1] |= 0x80000000;
+
+	REENTRANT_CHECK(OFF);
+/*	    verify_area(VERIFY_WRITE, (void *) dfloat, 8);*/
+	suword((u_long *) dfloat, l[0]);
+	suword((u_long *) dfloat + 1, l[1]);
+/*
+	suword(l[0], (unsigned long *) dfloat);
+	suword(l[1], 1 + (unsigned long *) dfloat);*/
+	REENTRANT_CHECK(ON);
+
+	return 1;
+}
+
+
+/* Put a float into user memory */
+int
+reg_store_single(void)
+{
+	float  *single = (float *) FPU_data_address;
+	long    templ;
+
+	if (FPU_st0_tag == TW_Valid) {
+		int     exp;
+		FPU_REG tmp;
+
+		reg_move(FPU_st0_ptr, &tmp);
+		exp = tmp.exp - EXP_BIAS;
+
+		if (exp < SINGLE_Emin) {
+			/* Make a de-normal */
+			int     precision_loss;
+
+			if (exp <= -EXTENDED_Ebias)
+				EXCEPTION(EX_Denormal);
+
+			tmp.exp += -SINGLE_Emin + 23;	/* largest exp to be 22 */
+
+			if ((precision_loss = round_to_int(&tmp))) {
+#ifdef PECULIAR_486
+				/* Did it round to a non-denormal ? */
+				/* This behaviour might be regarded as
+				 * peculiar, it appears that the 80486 rounds
+				 * to the dest precision, then converts to
+				 * decide underflow. */
+				if ((tmp.sigl == 0x00800000) &&
+				    ((FPU_st0_ptr->sigh & 0x000000ff) || FPU_st0_ptr->sigl))
+					EXCEPTION(precision_loss);
+				else
+#endif				/* PECULIAR_486 */
+				{
+					EXCEPTION(EX_Underflow | precision_loss);
+					/* This is a special case: see sec
+					 * 16.2.5.1 of the 80486 book */
+					if (!(control_word & EX_Underflow))
+						return 0;
+				}
+			}
+			templ = tmp.sigl;
+		} else {
+			if (tmp.sigl | (tmp.sigh & 0x000000ff)) {
+				unsigned long increment = 0;	/* avoid gcc warnings */
+				unsigned long sigh = tmp.sigh;
+				unsigned long sigl = tmp.sigl;
+
+				switch (control_word & CW_RC) {
+				case RC_RND:
+					increment = ((sigh & 0xff) > 0x80)	/* more than half */
+					    ||(((sigh & 0xff) == 0x80) && sigl)	/* more than half */
+					    ||((sigh & 0x180) == 0x180);	/* round to even */
+					break;
+				case RC_DOWN:	/* towards -infinity */
+					increment = (tmp.sign == SIGN_POS)
+					    ? 0 : (sigl | (sigh & 0xff));
+					break;
+				case RC_UP:	/* towards +infinity */
+					increment = (tmp.sign == SIGN_POS)
+					    ? (sigl | (sigh & 0xff)) : 0;
+					break;
+				case RC_CHOP:
+					increment = 0;
+					break;
+				}
+
+				/* Truncate part of the mantissa */
+				tmp.sigl = 0;
+
+				if (increment) {
+					set_precision_flag_up();
+
+					if (sigh >= 0xffffff00) {
+						/* The sigh part overflows */
+						tmp.sigh = 0x80000000;
+						exp++;
+						if (exp >= EXP_OVER)
+							goto overflow;
+					} else {
+						tmp.sigh &= 0xffffff00;
+						tmp.sigh += 0x100;
+					}
+				} else {
+					set_precision_flag_down();
+					tmp.sigh &= 0xffffff00;	/* Finish the truncation */
+				}
+			}
+			templ = (tmp.sigh >> 8) & 0x007fffff;
+
+			if (exp > SINGLE_Emax) {
+		overflow:
+				EXCEPTION(EX_Overflow);
+				/* This is a special case: see sec 16.2.5.1 of
+				 * the 80486 book */
+				if (control_word & EX_Overflow) {
+					/* Overflow to infinity */
+					templ = 0x7f800000;
+				} else
+					return 0;
+			} else
+				templ |= ((exp + SINGLE_Ebias) & 0xff) << 23;
+		}
+	} else
+		if (FPU_st0_tag == TW_Zero) {
+			templ = 0;
+		} else
+			if (FPU_st0_tag == TW_Infinity) {
+				templ = 0x7f800000;
+			} else
+				if (FPU_st0_tag == TW_NaN) {
+					/* See if we can get a valid NaN from
+					 * the FPU_REG */
+					templ = FPU_st0_ptr->sigh >> 8;
+					if (!(templ & 0x3fffff)) {
+						/* This case does not seem to
+						 * be handled by the 80486
+						 * specs */
+						EXCEPTION(EX_Invalid);
+						/* Make the quiet NaN "real
+						 * indefinite" */
+						goto put_indefinite;
+					}
+					templ |= 0x7f800000;
+				} else
+					if (FPU_st0_tag == TW_Empty) {
+						/* Empty register (stack
+						 * underflow) */
+						EXCEPTION(EX_StackUnder);
+						if (control_word & EX_Invalid) {
+							/* The masked response */
+							/* Put out the QNaN
+							 * indefinite */
+					put_indefinite:
+							REENTRANT_CHECK(OFF);
+/*							    verify_area(VERIFY_WRITE, (void *) single, 4); */
+							suword((unsigned long *) single, 0xffc00000);
+							REENTRANT_CHECK(ON);
+							return 1;
+						} else
+							return 0;
+					}
+#if 0				/* TW_Denormal is not used yet, and probably
+				 * won't be */
+					else
+						if (FPU_st0_tag == TW_Denormal) {
+							/* Extended real ->
+							 * real will always
+							 * underflow */
+							templ = 0;
+							EXCEPTION(EX_Underflow);
+						}
+#endif
+#ifdef PARANOID
+						else {
+							EXCEPTION(EX_INTERNAL | 0x106);
+							return 0;
+						}
+#endif
+	if (FPU_st0_ptr->sign)
+		templ |= 0x80000000;
+
+	REENTRANT_CHECK(OFF);
+/*	    verify_area(VERIFY_WRITE, (void *) single, 4); */
+	suword((unsigned long *) single, templ);
+	REENTRANT_CHECK(ON);
+
+	return 1;
+}
+
+
+/* Put a long long into user memory */
+int
+reg_store_int64(void)
+{
+	long long *d = (long long *) FPU_data_address;
+	FPU_REG t;
+	long long tll;
+
+	if (FPU_st0_tag == TW_Empty) {
+		/* Empty register (stack underflow) */
+		EXCEPTION(EX_StackUnder);
+		if (control_word & EX_Invalid) {
+			/* The masked response */
+			/* Put out the QNaN indefinite */
+			goto put_indefinite;
+		} else
+			return 0;
+	}
+	reg_move(FPU_st0_ptr, &t);
+	round_to_int(&t);
+	((long *) &tll)[0] = t.sigl;
+	((long *) &tll)[1] = t.sigh;
+	if ((t.sigh & 0x80000000) &&
+	    !((t.sigh == 0x80000000) && (t.sigl == 0) && (t.sign == SIGN_NEG))) {
+		EXCEPTION(EX_Invalid);
+		/* This is a special case: see sec 16.2.5.1 of the 80486 book */
+		if (control_word & EX_Invalid) {
+			/* Produce "indefinite" */
+	put_indefinite:
+			((long *) &tll)[1] = 0x80000000;
+			((long *) &tll)[0] = 0;
+		} else
+			return 0;
+	} else
+		if (t.sign)
+			tll = -tll;
+
+	REENTRANT_CHECK(OFF);
+/*	    verify_area(VERIFY_WRITE, (void *) d, 8); */
+	suword((unsigned long *) d, ((long *) &tll)[0]);
+	suword(1 + (unsigned long *) d, ((long *) &tll)[1]);
+	REENTRANT_CHECK(ON);
+
+	return 1;
+}
+
+
+/* Put a long into user memory */
+int
+reg_store_int32(void)
+{
+	long   *d = (long *) FPU_data_address;
+	FPU_REG t;
+
+	if (FPU_st0_tag == TW_Empty) {
+		/* Empty register (stack underflow) */
+		EXCEPTION(EX_StackUnder);
+		if (control_word & EX_Invalid) {
+			/* The masked response */
+			/* Put out the QNaN indefinite */
+			REENTRANT_CHECK(OFF);
+/*			    verify_area(VERIFY_WRITE, d, 4);*/
+			suword((unsigned long *) d, 0x80000000);
+			REENTRANT_CHECK(ON);
+			return 1;
+		} else
+			return 0;
+	}
+	reg_move(FPU_st0_ptr, &t);
+	round_to_int(&t);
+	if (t.sigh ||
+	    ((t.sigl & 0x80000000) &&
+		!((t.sigl == 0x80000000) && (t.sign == SIGN_NEG)))) {
+		EXCEPTION(EX_Invalid);
+		/* This is a special case: see sec 16.2.5.1 of the 80486 book */
+		if (control_word & EX_Invalid) {
+			/* Produce "indefinite" */
+			t.sigl = 0x80000000;
+		} else
+			return 0;
+	} else
+		if (t.sign)
+			t.sigl = -(long) t.sigl;
+
+	REENTRANT_CHECK(OFF);
+/*	    verify_area(VERIFY_WRITE, d, 4); */
+	suword((unsigned long *) d, t.sigl);
+	REENTRANT_CHECK(ON);
+
+	return 1;
+}
+
+
+/* Put a short into user memory */
+int
+reg_store_int16(void)
+{
+	short  *d = (short *) FPU_data_address;
+	FPU_REG t;
+	short   ts;
+
+	if (FPU_st0_tag == TW_Empty) {
+		/* Empty register (stack underflow) */
+		EXCEPTION(EX_StackUnder);
+		if (control_word & EX_Invalid) {
+			/* The masked response */
+			/* Put out the QNaN indefinite */
+			REENTRANT_CHECK(OFF);
+/*			    verify_area(VERIFY_WRITE, d, 2);*/
+			suword((unsigned short *) d, 0x8000);
+			REENTRANT_CHECK(ON);
+			return 1;
+		} else
+			return 0;
+	}
+	reg_move(FPU_st0_ptr, &t);
+	round_to_int(&t);
+	if (t.sigh ||
+	    ((t.sigl & 0xffff8000) &&
+		!((t.sigl == 0x8000) && (t.sign == SIGN_NEG)))) {
+		EXCEPTION(EX_Invalid);
+		/* This is a special case: see sec 16.2.5.1 of the 80486 book */
+		if (control_word & EX_Invalid) {
+			/* Produce "indefinite" */
+			ts = 0x8000;
+		} else
+			return 0;
+	} else
+		if (t.sign)
+			t.sigl = -t.sigl;
+
+	REENTRANT_CHECK(OFF);
+/*	    verify_area(VERIFY_WRITE, d, 2); */
+	suword((short *) d, (short) t.sigl);
+	REENTRANT_CHECK(ON);
+
+	return 1;
+}
+
+
+/* Put a packed bcd array into user memory */
+int
+reg_store_bcd(void)
+{
+	char   *d = (char *) FPU_data_address;
+	FPU_REG t;
+	long long ll;
+	unsigned char b;
+	int     i;
+	unsigned char sign = (FPU_st0_ptr->sign == SIGN_NEG) ? 0x80 : 0;
+
+	if (FPU_st0_tag == TW_Empty) {
+		/* Empty register (stack underflow) */
+		EXCEPTION(EX_StackUnder);
+		if (control_word & EX_Invalid) {
+			/* The masked response */
+			/* Put out the QNaN indefinite */
+			goto put_indefinite;
+		} else
+			return 0;
+	}
+	reg_move(FPU_st0_ptr, &t);
+	round_to_int(&t);
+	ll = *(long long *) (&t.sigl);
+
+	/* Check for overflow, by comparing with 999999999999999999 decimal. */
+	if ((t.sigh > 0x0de0b6b3) ||
+	    ((t.sigh == 0x0de0b6b3) && (t.sigl > 0xa763ffff))) {
+		EXCEPTION(EX_Invalid);
+		/* This is a special case: see sec 16.2.5.1 of the 80486 book */
+		if (control_word & EX_Invalid) {
+	put_indefinite:
+			/* Produce "indefinite" */
+			REENTRANT_CHECK(OFF);
+/*			    verify_area(VERIFY_WRITE, d, 10);*/
+			subyte((unsigned char *) d + 7, 0xff);
+			subyte((unsigned char *) d + 8, 0xff);
+			subyte((unsigned char *) d + 9, 0xff);
+			REENTRANT_CHECK(ON);
+			return 1;
+		} else
+			return 0;
+	}
+/*	verify_area(VERIFY_WRITE, d, 10);*/
+	for (i = 0; i < 9; i++) {
+		b = div_small(&ll, 10);
+		b |= (div_small(&ll, 10)) << 4;
+		REENTRANT_CHECK(OFF);
+		subyte((unsigned char *) d + i, b);
+		REENTRANT_CHECK(ON);
+	}
+	REENTRANT_CHECK(OFF);
+	subyte((unsigned char *) d + 9, sign);
+	REENTRANT_CHECK(ON);
+
+	return 1;
+}
+/*===========================================================================*/
+
+/* r gets mangled such that sig is int, sign:
+   it is NOT normalized */
+/* The return value (in eax) is zero if the result is exact,
+   if bits are changed due to rounding, truncation, etc, then
+   a non-zero value is returned */
+/* Overflow is signalled by a non-zero return value (in eax).
+   In the case of overflow, the returned significand always has the
+   the largest possible value */
+/* The value returned in eax is never actually needed :-) */
+int
+round_to_int(FPU_REG * r)
+{
+	char    very_big;
+	unsigned eax;
+
+	if (r->tag == TW_Zero) {
+		/* Make sure that zero is returned */
+		*(long long *) &r->sigl = 0;
+		return 0;	/* o.k. */
+	}
+	if (r->exp > EXP_BIAS + 63) {
+		r->sigl = r->sigh = ~0;	/* The largest representable number */
+		return 1;	/* overflow */
+	}
+	eax = shrxs(&r->sigl, EXP_BIAS + 63 - r->exp);
+	very_big = !(~(r->sigh) | ~(r->sigl));	/* test for 0xfff...fff */
+#define	half_or_more	(eax & 0x80000000)
+#define	frac_part	(eax)
+#define more_than_half  ((eax & 0x80000001) == 0x80000001)
+	switch (control_word & CW_RC) {
+	case RC_RND:
+		if (more_than_half	/* nearest */
+		    || (half_or_more && (r->sigl & 1))) {	/* odd -> even */
+			if (very_big)
+				return 1;	/* overflow */
+			(*(long long *) (&r->sigl))++;
+			return LOST_UP;
+		}
+		break;
+	case RC_DOWN:
+		if (frac_part && r->sign) {
+			if (very_big)
+				return 1;	/* overflow */
+			(*(long long *) (&r->sigl))++;
+			return LOST_UP;
+		}
+		break;
+	case RC_UP:
+		if (frac_part && !r->sign) {
+			if (very_big)
+				return 1;	/* overflow */
+			(*(long long *) (&r->sigl))++;
+			return LOST_UP;
+		}
+		break;
+	case RC_CHOP:
+		break;
+	}
+
+	return eax ? LOST_DOWN : 0;
+
+}
+/*===========================================================================*/
+
+char   *
+fldenv(void)
+{
+	char   *s = (char *) FPU_data_address;
+	unsigned short tag_word = 0;
+	unsigned char tag;
+	int     i;
+
+	REENTRANT_CHECK(OFF);
+	control_word = fuword((unsigned short *) s);
+	status_word = fuword((unsigned short *) (s + 4));
+	tag_word = fuword((unsigned short *) (s + 8));
+	ip_offset = fuword((unsigned long *) (s + 0x0c));
+	cs_selector = fuword((unsigned long *) (s + 0x10));
+	data_operand_offset = fuword((unsigned long *) (s + 0x14));
+	operand_selector = fuword((unsigned long *) (s + 0x18));
+	REENTRANT_CHECK(ON);
+
+	top = (status_word >> SW_Top_Shift) & 7;
+
+	for (i = 0; i < 8; i++) {
+		tag = tag_word & 3;
+		tag_word >>= 2;
+
+		switch (tag) {
+		case 0:
+			regs[i].tag = TW_Valid;
+			break;
+		case 1:
+			regs[i].tag = TW_Zero;
+			break;
+		case 2:
+			regs[i].tag = TW_NaN;
+			break;
+		case 3:
+			regs[i].tag = TW_Empty;
+			break;
+		}
+	}
+
+	FPU_data_address = (void *) data_operand_offset;	/* We want no net effect */
+	FPU_entry_eip = ip_offset;	/* We want no net effect */
+
+	return s + 0x1c;
+}
+
+
+void
+frstor(void)
+{
+	int     i, stnr;
+	unsigned char tag;
+	unsigned short saved_status, saved_control;
+	char   *s = (char *) fldenv();
+
+	saved_status = status_word;
+	saved_control = control_word;
+	control_word = 0x037f;	/* Mask all interrupts while we load. */
+	for (i = 0; i < 8; i++) {
+		/* load each register */
+		FPU_data_address = (void *) (s + i * 10);
+		reg_load_extended();
+		stnr = (i + top) & 7;
+		tag = regs[stnr].tag;	/* derived from the loaded tag word */
+		reg_move(&FPU_loaded_data, &regs[stnr]);
+		if (tag == TW_NaN) {
+			/* The current data is a special, i.e. NaN,
+			 * unsupported, infinity, or denormal */
+			unsigned char t = regs[stnr].tag;	/* derived from the new
+								 * data */
+			if ( /* (t == TW_Valid) || *** */ (t == TW_Zero))
+				regs[stnr].tag = TW_NaN;
+		} else
+			regs[stnr].tag = tag;
+	}
+	control_word = saved_control;
+	status_word = saved_status;
+
+	FPU_data_address = (void *) data_operand_offset;	/* We want no net effect */
+}
+
+
+unsigned short
+tag_word(void)
+{
+	unsigned short word = 0;
+	unsigned char tag;
+	int     i;
+
+	for (i = 7; i >= 0; i--) {
+		switch (tag = regs[i].tag) {
+#if 0				/* TW_Denormal is not used yet, and probably
+				 * won't be */
+		case TW_Denormal:
+#endif
+		case TW_Valid:
+			if (regs[i].exp <= (EXP_BIAS - EXTENDED_Ebias))
+				tag = 2;
+			break;
+		case TW_Infinity:
+		case TW_NaN:
+			tag = 2;
+			break;
+		case TW_Empty:
+			tag = 3;
+			break;
+			/* TW_Valid and TW_Zero already have the correct value */
+		}
+		word <<= 2;
+		word |= tag;
+	}
+	return word;
+}
+
+
+char   *
+fstenv(void)
+{
+	char   *d = (char *) FPU_data_address;
+
+/*	verify_area(VERIFY_WRITE, d, 28);*/
+
+#if 0				/****/
+	*(unsigned short *) &cs_selector = fpu_cs;
+	*(unsigned short *) &operand_selector = fpu_os;
+#endif				/****/
+
+	REENTRANT_CHECK(OFF);
+	suword((unsigned short *) d, control_word);
+	suword((unsigned short *) (d + 4), (status_word & ~SW_Top) | ((top & 7) << SW_Top_Shift));
+	suword((unsigned short *) (d + 8), tag_word());
+	suword((unsigned long *) (d + 0x0c), ip_offset);
+	suword((unsigned long *) (d + 0x10), cs_selector);
+	suword((unsigned long *) (d + 0x14), data_operand_offset);
+	suword((unsigned long *) (d + 0x18), operand_selector);
+	REENTRANT_CHECK(ON);
+
+	return d + 0x1c;
+}
+
+
+void
+fsave(void)
+{
+	char   *d;
+	FPU_REG tmp, *rp;
+	int     i;
+	short   e;
+
+	d = fstenv();
+/*	verify_area(VERIFY_WRITE, d, 80);*/
+	for (i = 0; i < 8; i++) {
+		/* Store each register in the order: st(0), st(1), ... */
+		rp = &regs[(top + i) & 7];
+
+		e = rp->exp - EXP_BIAS + EXTENDED_Ebias;
+
+		if (rp->tag == TW_Valid) {
+			if (e >= 0x7fff) {
+				/* Overflow to infinity */
+				REENTRANT_CHECK(OFF);
+				suword((unsigned long *) (d + i * 10), 0);
+				suword((unsigned long *) (d + i * 10 + 4), 0);
+				REENTRANT_CHECK(ON);
+				e = 0x7fff;
+			} else
+				if (e <= 0) {
+					if (e > -63) {
+						/* Make a de-normal */
+						reg_move(rp, &tmp);
+						tmp.exp += -EXTENDED_Emin + 63;	/* largest exp to be 62 */
+						round_to_int(&tmp);
+						REENTRANT_CHECK(OFF);
+						suword((unsigned long *) (d + i * 10), tmp.sigl);
+						suword((unsigned long *) (d + i * 10 + 4), tmp.sigh);
+						REENTRANT_CHECK(ON);
+					} else {
+						/* Underflow to zero */
+						REENTRANT_CHECK(OFF);
+						suword((unsigned long *) (d + i * 10), 0);
+						suword((unsigned long *) (d + i * 10 + 4), 0);
+						REENTRANT_CHECK(ON);
+					}
+					e = 0;
+				} else {
+					REENTRANT_CHECK(OFF);
+					suword((unsigned long *) (d + i * 10), rp->sigl);
+					suword((unsigned long *) (d + i * 10 + 4), rp->sigh);
+					REENTRANT_CHECK(ON);
+				}
+		} else
+			if (rp->tag == TW_Zero) {
+				REENTRANT_CHECK(OFF);
+				suword((unsigned long *) (d + i * 10), 0);
+				suword((unsigned long *) (d + i * 10 + 4), 0);
+				REENTRANT_CHECK(ON);
+				e = 0;
+			} else
+				if (rp->tag == TW_Infinity) {
+					REENTRANT_CHECK(OFF);
+					suword((unsigned long *) (d + i * 10), 0);
+					suword((unsigned long *) (d + i * 10 + 4), 0x80000000);
+					REENTRANT_CHECK(ON);
+					e = 0x7fff;
+				} else
+					if (rp->tag == TW_NaN) {
+						REENTRANT_CHECK(OFF);
+						suword((unsigned long *) (d + i * 10), rp->sigl);
+						suword((unsigned long *) (d + i * 10 + 4), rp->sigh);
+						REENTRANT_CHECK(ON);
+						e = 0x7fff;
+					} else
+						if (rp->tag == TW_Empty) {
+							/* just copy the reg */
+							REENTRANT_CHECK(OFF);
+							suword((unsigned long *) (d + i * 10), rp->sigl);
+							suword((unsigned long *) (d + i * 10 + 4), rp->sigh);
+							REENTRANT_CHECK(ON);
+						}
+		e |= rp->sign == SIGN_POS ? 0 : 0x8000;
+		REENTRANT_CHECK(OFF);
+		suword((unsigned short *) (d + i * 10 + 8), e);
+		REENTRANT_CHECK(ON);
+	}
+
+	finit();
+
+}
+/*===========================================================================*/
diff --git a/sys/gnu/i386/fpemul/reg_mul.c b/sys/gnu/i386/fpemul/reg_mul.c
new file mode 100644
index 0000000..4ae5fb3
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_mul.c
@@ -0,0 +1,149 @@
+/*
+ *  reg_mul.c
+ *
+ * Multiply one FPU_REG by another, put the result in a destination FPU_REG.
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*---------------------------------------------------------------------------+
+ | The destination may be any FPU_REG, including one of the source FPU_REGs. |
+ +---------------------------------------------------------------------------*/
+
+#include "exception.h"
+#include "reg_constant.h"
+#include "fpu_emu.h"
+#include "fpu_system.h"
+
+
+/* This routine must be called with non-empty source registers */
+void
+reg_mul(FPU_REG * a, FPU_REG * b, FPU_REG * dest, unsigned int control_w)
+{
+	char    sign = (a->sign ^ b->sign);
+
+	if (!(a->tag | b->tag)) {
+		/* This should be the most common case */
+		reg_u_mul(a, b, dest, control_w);
+		dest->sign = sign;
+		return;
+	} else
+		if ((a->tag <= TW_Zero) && (b->tag <= TW_Zero)) {
+#ifdef DENORM_OPERAND
+			if (((b->tag == TW_Valid) && (b->exp <= EXP_UNDER)) ||
+			    ((a->tag == TW_Valid) && (a->exp <= EXP_UNDER))) {
+				if (denormal_operand())
+					return;
+			}
+#endif				/* DENORM_OPERAND */
+			/* Must have either both arguments == zero, or one
+			 * valid and the other zero. The result is therefore
+			 * zero. */
+			reg_move(&CONST_Z, dest);
+#ifdef PECULIAR_486
+			/* The 80486 book says that the answer is +0, but a
+			 * real 80486 appears to behave this way... */
+			dest->sign = sign;
+#endif				/* PECULIAR_486 */
+			return;
+		}
+#if 0				/* TW_Denormal is not used yet... perhaps
+				 * never will be. */
+		else
+			if ((a->tag <= TW_Denormal) && (b->tag <= TW_Denormal)) {
+				/* One or both arguments are de-normalized */
+				/* Internal de-normalized numbers are not
+				 * supported yet */
+				EXCEPTION(EX_INTERNAL | 0x105);
+				reg_move(&CONST_Z, dest);
+			}
+#endif
+			else {
+				/* Must have infinities, NaNs, etc */
+				if ((a->tag == TW_NaN) || (b->tag == TW_NaN)) {
+					real_2op_NaN(a, b, dest);
+					return;
+				} else
+					if (a->tag == TW_Infinity) {
+						if (b->tag == TW_Zero) {
+							arith_invalid(dest);
+							return;
+						}
+						/* Zero*Infinity is invalid */
+						else {
+#ifdef DENORM_OPERAND
+							if ((b->tag == TW_Valid) && (b->exp <= EXP_UNDER) &&
+							    denormal_operand())
+								return;
+#endif				/* DENORM_OPERAND */
+							reg_move(a, dest);
+							dest->sign = sign;
+						}
+						return;
+					} else
+						if (b->tag == TW_Infinity) {
+							if (a->tag == TW_Zero) {
+								arith_invalid(dest);
+								return;
+							}
+							/* Zero*Infinity is
+							 * invalid */
+							else {
+#ifdef DENORM_OPERAND
+								if ((a->tag == TW_Valid) && (a->exp <= EXP_UNDER) &&
+								    denormal_operand())
+									return;
+#endif				/* DENORM_OPERAND */
+								reg_move(b, dest);
+								dest->sign = sign;
+							}
+							return;
+						}
+#ifdef PARANOID
+						else {
+							EXCEPTION(EX_INTERNAL | 0x102);
+						}
+#endif				/* PARANOID */
+			}
+}
diff --git a/sys/gnu/i386/fpemul/reg_norm.s b/sys/gnu/i386/fpemul/reg_norm.s
new file mode 100644
index 0000000..261c9b0
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_norm.s
@@ -0,0 +1,169 @@
+/*
+ *  reg_norm.s
+ *
+ * Normalize the value in a FPU_REG.
+ *
+ * Call from C as:
+ *   void normalize(FPU_REG *n)
+ *
+ *   void normalize_nuo(FPU_REG *n)
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include "fpu_asm.h"
+
+
+.text
+
+	.align 2,144
+.globl _normalize
+
+_normalize:
+	pushl	%ebp
+	movl	%esp,%ebp
+	pushl	%ebx
+
+	movl	PARAM1,%ebx
+
+	movl	SIGH(%ebx),%edx
+	movl	SIGL(%ebx),%eax
+
+	orl	%edx,%edx	/* ms bits */
+	js	L_done		/* Already normalized */
+	jnz	L_shift_1	/* Shift left 1 - 31 bits */
+
+	orl	%eax,%eax
+	jz	L_zero		/* The contents are zero */
+
+/* L_shift_32: */
+	movl	%eax,%edx
+	xorl	%eax,%eax
+	subl	$32,EXP(%ebx)	/* This can cause an underflow */
+
+/* We need to shift left by 1 - 31 bits */
+L_shift_1:
+	bsrl	%edx,%ecx	/* get the required shift in %ecx */
+	subl	$31,%ecx
+	negl	%ecx
+	shld	%cl,%eax,%edx
+	shl	%cl,%eax
+	subl	%ecx,EXP(%ebx)	/* This can cause an underflow */
+
+	movl	%edx,SIGH(%ebx)
+	movl	%eax,SIGL(%ebx)
+
+L_done:
+	cmpl	EXP_OVER,EXP(%ebx)
+	jge	L_overflow
+
+	cmpl	EXP_UNDER,EXP(%ebx)
+	jle	L_underflow
+
+L_exit:
+	popl	%ebx
+	leave
+	ret
+
+
+L_zero:
+	movl	EXP_UNDER,EXP(%ebx)
+	movb	TW_Zero,TAG(%ebx)
+	jmp	L_exit
+
+L_underflow:
+	push	%ebx
+	call	_arith_underflow
+	pop	%ebx
+	jmp	L_exit
+
+L_overflow:
+	push	%ebx
+	call	_arith_overflow
+	pop	%ebx
+	jmp	L_exit
+
+
+
+/* Normalise without reporting underflow or overflow */
+	.align 2,144
+.globl _normalize_nuo
+
+_normalize_nuo:
+	pushl	%ebp
+	movl	%esp,%ebp
+	pushl	%ebx
+
+	movl	PARAM1,%ebx
+
+	movl	SIGH(%ebx),%edx
+	movl	SIGL(%ebx),%eax
+
+	orl	%edx,%edx	/* ms bits */
+	js	L_exit		/* Already normalized */
+	jnz	L_nuo_shift_1	/* Shift left 1 - 31 bits */
+
+	orl	%eax,%eax
+	jz	L_zero		/* The contents are zero */
+
+/* L_nuo_shift_32: */
+	movl	%eax,%edx
+	xorl	%eax,%eax
+	subl	$32,EXP(%ebx)	/* This can cause an underflow */
+
+/* We need to shift left by 1 - 31 bits */
+L_nuo_shift_1:
+	bsrl	%edx,%ecx	/* get the required shift in %ecx */
+	subl	$31,%ecx
+	negl	%ecx
+	shld	%cl,%eax,%edx
+	shl	%cl,%eax
+	subl	%ecx,EXP(%ebx)	/* This can cause an underflow */
+
+	movl	%edx,SIGH(%ebx)
+	movl	%eax,SIGL(%ebx)
+	jmp	L_exit
+
+
diff --git a/sys/gnu/i386/fpemul/reg_round.s b/sys/gnu/i386/fpemul/reg_round.s
new file mode 100644
index 0000000..91a8a16
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_round.s
@@ -0,0 +1,640 @@
+	.file "reg_round.S"
+/*
+ *  reg_round.S
+ *
+ * Rounding/truncation/etc for FPU basic arithmetic functions.
+ *
+ * This code has four possible entry points.
+ * The following must be entered by a jmp intruction:
+ *   FPU_round, FPU_round_sqrt, and FPU_Arith_exit.
+ *
+ * The _round_reg entry point is intended to be used by C code.
+ * From C, call as:
+ * void round_reg(FPU_REG *arg, unsigned int extent, unsigned int control_w)
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+/*---------------------------------------------------------------------------+
+ | Four entry points.                                                        |
+ |                                                                           |
+ | Needed by both the FPU_round and FPU_round_sqrt entry points:             |
+ |  %eax:%ebx  64 bit significand                                            |
+ |  %edx       32 bit extension of the significand                           |
+ |  %edi       pointer to an FPU_REG for the result to be stored             |
+ |  stack      calling function must have set up a C stack frame and         |
+ |             pushed %esi, %edi, and %ebx                                   |
+ |                                                                           |
+ | Needed just for the FPU_round_sqrt entry point:                           |
+ |  %cx  A control word in the same format as the FPU control word.          |
+ | Otherwise, PARAM4 must give such a value.                                 |
+ |                                                                           |
+ |                                                                           |
+ | The significand and its extension are assumed to be exact in the          |
+ | following sense:                                                          |
+ |   If the significand by itself is the exact result then the significand   |
+ |   extension (%edx) must contain 0, otherwise the significand extension    |
+ |   must be non-zero.                                                       |
+ |   If the significand extension is non-zero then the significand is        |
+ |   smaller than the magnitude of the correct exact result by an amount     |
+ |   greater than zero and less than one ls bit of the significand.          |
+ |   The significand extension is only required to have three possible       |
+ |   non-zero values:                                                        |
+ |       less than 0x80000000  <=> the significand is less than 1/2 an ls    |
+ |                                 bit smaller than the magnitude of the     |
+ |                                 true exact result.                        |
+ |         exactly 0x80000000  <=> the significand is exactly 1/2 an ls bit  |
+ |                                 smaller than the magnitude of the true    |
+ |                                 exact result.                             |
+ |    greater than 0x80000000  <=> the significand is more than 1/2 an ls    |
+ |                                 bit smaller than the magnitude of the     |
+ |                                 true exact result.                        |
+ |                                                                           |
+ +---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------+
+ |  The code in this module has become quite complex, but it should handle   |
+ |  all of the FPU flags which are set at this stage of the basic arithmetic |
+ |  computations.                                                            |
+ |  There are a few rare cases where the results are not set identically to  |
+ |  a real FPU. These require a bit more thought because at this stage the   |
+ |  results of the code here appear to be more consistent...                 |
+ |  This may be changed in a future version.                                 |
+ +---------------------------------------------------------------------------*/
+
+
+#include "fpu_asm.h"
+#include "exception.h"
+#include "control_w.h"
+
+#define	LOST_DOWN	$1
+#define	LOST_UP		$2
+#define	DENORMAL	$1
+#define	UNMASKED_UNDERFLOW $2
+
+.data
+	.align 2,0
+FPU_bits_lost:
+	.byte	0
+FPU_denormal:
+	.byte	0
+
+.text
+	.align 2,144
+.globl FPU_round
+.globl FPU_round_sqrt
+.globl FPU_Arith_exit
+.globl _round_reg
+
+/* Entry point when called from C */
+_round_reg:
+	pushl	%ebp
+	movl	%esp,%ebp
+	pushl	%esi
+	pushl	%edi
+	pushl	%ebx
+
+	movl	PARAM1,%edi
+	movl	SIGH(%edi),%eax
+	movl	SIGL(%edi),%ebx
+	movl	PARAM2,%edx
+	movl	PARAM3,%ecx
+	jmp	FPU_round_sqrt
+
+FPU_round:		/* Normal entry point */
+	movl	PARAM4,%ecx
+
+FPU_round_sqrt:		/* Entry point from wm_sqrt.S */
+
+#ifdef PARANOID
+/* Cannot use this here yet */
+/*	orl	%eax,%eax */
+/*	jns	L_entry_bugged */
+#endif PARANOID
+
+	cmpl	EXP_UNDER,EXP(%edi)
+	jle	xMake_denorm			/* The number is a de-normal*/
+
+	movb	$0,FPU_denormal			/* 0 -> not a de-normal*/
+
+xDenorm_done:
+	movb	$0,FPU_bits_lost		/*No bits yet lost in rounding*/
+
+	movl	%ecx,%esi
+	andl	CW_PC,%ecx
+	cmpl	PR_64_BITS,%ecx
+	je	LRound_To_64
+
+	cmpl	PR_53_BITS,%ecx
+	je	LRound_To_53
+
+	cmpl	PR_24_BITS,%ecx
+	je	LRound_To_24
+
+#ifdef PARANOID
+	jmp	L_bugged	/* There is no bug, just a bad control word */
+#endif PARANOID
+
+
+/* Round etc to 24 bit precision */
+LRound_To_24:
+	movl	%esi,%ecx
+	andl	CW_RC,%ecx
+	cmpl	RC_RND,%ecx
+	je	LRound_nearest_24
+
+	cmpl	RC_CHOP,%ecx
+	je	LCheck_truncate_24
+
+	cmpl	RC_UP,%ecx		/* Towards +infinity */
+	je	LUp_24
+
+	cmpl	RC_DOWN,%ecx		/* Towards -infinity */
+	je	LDown_24
+
+#ifdef PARANOID
+	jmp	L_bugged
+#endif PARANOID
+
+LUp_24:
+	cmpb	SIGN_POS,SIGN(%edi)
+	jne	LCheck_truncate_24	/* If negative then  up==truncate */
+
+	jmp	LCheck_24_round_up
+
+LDown_24:
+	cmpb	SIGN_POS,SIGN(%edi)
+	je	LCheck_truncate_24	/* If positive then  down==truncate */
+
+LCheck_24_round_up:
+	movl	%eax,%ecx
+	andl	$0x000000ff,%ecx
+	orl	%ebx,%ecx
+	orl	%edx,%ecx
+	jnz	LDo_24_round_up
+	jmp	LRe_normalise
+
+LRound_nearest_24:
+	/* Do rounding of the 24th bit if needed (nearest or even) */
+	movl	%eax,%ecx
+	andl	$0x000000ff,%ecx
+	cmpl	$0x00000080,%ecx
+	jc	LCheck_truncate_24	/*less than half, no increment needed*/
+
+	jne	LGreater_Half_24	/* greater than half, increment needed*/
+
+	/* Possibly half, we need to check the ls bits */
+	orl	%ebx,%ebx
+	jnz	LGreater_Half_24	/* greater than half, increment needed*/
+
+	orl	%edx,%edx
+	jnz	LGreater_Half_24	/* greater than half, increment needed*/
+
+	/* Exactly half, increment only if 24th bit is 1 (round to even)*/
+	testl	$0x00000100,%eax
+	jz	LDo_truncate_24
+
+LGreater_Half_24:			/*Rounding: increment at the 24th bit*/
+LDo_24_round_up:
+	andl	$0xffffff00,%eax	/*Truncate to 24 bits*/
+	xorl	%ebx,%ebx
+	movb	LOST_UP,FPU_bits_lost
+	addl	$0x00000100,%eax
+	jmp	LCheck_Round_Overflow
+
+LCheck_truncate_24:
+	movl	%eax,%ecx
+	andl	$0x000000ff,%ecx
+	orl	%ebx,%ecx
+	orl	%edx,%ecx
+	jz	LRe_normalise			/* No truncation needed*/
+
+LDo_truncate_24:
+	andl	$0xffffff00,%eax	/* Truncate to 24 bits*/
+	xorl	%ebx,%ebx
+	movb	LOST_DOWN,FPU_bits_lost
+	jmp	LRe_normalise
+
+
+/* Round etc to 53 bit precision */
+LRound_To_53:
+	movl	%esi,%ecx
+	andl	CW_RC,%ecx
+	cmpl	RC_RND,%ecx
+	je	LRound_nearest_53
+
+	cmpl	RC_CHOP,%ecx
+	je	LCheck_truncate_53
+
+	cmpl	RC_UP,%ecx		/* Towards +infinity*/
+	je	LUp_53
+
+	cmpl	RC_DOWN,%ecx		/* Towards -infinity*/
+	je	LDown_53
+
+#ifdef PARANOID
+	jmp	L_bugged
+#endif PARANOID
+
+LUp_53:
+	cmpb	SIGN_POS,SIGN(%edi)
+	jne	LCheck_truncate_53	/* If negative then  up==truncate*/
+
+	jmp	LCheck_53_round_up
+
+LDown_53:
+	cmpb	SIGN_POS,SIGN(%edi)
+	je	LCheck_truncate_53	/* If positive then  down==truncate*/
+
+LCheck_53_round_up:
+	movl	%ebx,%ecx
+	andl	$0x000007ff,%ecx
+	orl	%edx,%ecx
+	jnz	LDo_53_round_up
+	jmp	LRe_normalise
+
+LRound_nearest_53:
+	/*Do rounding of the 53rd bit if needed (nearest or even)*/
+	movl	%ebx,%ecx
+	andl	$0x000007ff,%ecx
+	cmpl	$0x00000400,%ecx
+	jc	LCheck_truncate_53	/* less than half, no increment needed*/
+
+	jnz	LGreater_Half_53	/* greater than half, increment needed*/
+
+	/*Possibly half, we need to check the ls bits*/
+	orl	%edx,%edx
+	jnz	LGreater_Half_53	/* greater than half, increment needed*/
+
+	/* Exactly half, increment only if 53rd bit is 1 (round to even)*/
+	testl	$0x00000800,%ebx
+	jz	LTruncate_53
+
+LGreater_Half_53:			/*Rounding: increment at the 53rd bit*/
+LDo_53_round_up:
+	movb	LOST_UP,FPU_bits_lost
+	andl	$0xfffff800,%ebx	/* Truncate to 53 bits*/
+	addl	$0x00000800,%ebx
+	adcl	$0,%eax
+	jmp	LCheck_Round_Overflow
+
+LCheck_truncate_53:
+	movl	%ebx,%ecx
+	andl	$0x000007ff,%ecx
+	orl	%edx,%ecx
+	jz	LRe_normalise
+
+LTruncate_53:
+	movb	LOST_DOWN,FPU_bits_lost
+	andl	$0xfffff800,%ebx	/* Truncate to 53 bits*/
+	jmp	LRe_normalise
+
+
+/* Round etc to 64 bit precision*/
+LRound_To_64:
+	movl	%esi,%ecx
+	andl	CW_RC,%ecx
+	cmpl	RC_RND,%ecx
+	je	LRound_nearest_64
+
+	cmpl	RC_CHOP,%ecx
+	je	LCheck_truncate_64
+
+	cmpl	RC_UP,%ecx		/* Towards +infinity*/
+	je	LUp_64
+
+	cmpl	RC_DOWN,%ecx		/* Towards -infinity*/
+	je	LDown_64
+
+#ifdef PARANOID
+	jmp	L_bugged
+#endif PARANOID
+
+LUp_64:
+	cmpb	SIGN_POS,SIGN(%edi)
+	jne	LCheck_truncate_64	/* If negative then  up==truncate*/
+
+	orl	%edx,%edx
+	jnz	LDo_64_round_up
+	jmp	LRe_normalise
+
+LDown_64:
+	cmpb	SIGN_POS,SIGN(%edi)
+	je	LCheck_truncate_64	/*If positive then  down==truncate*/
+
+	orl	%edx,%edx
+	jnz	LDo_64_round_up
+	jmp	LRe_normalise
+
+LRound_nearest_64:
+	cmpl	$0x80000000,%edx
+	jc	LCheck_truncate_64
+
+	jne	LDo_64_round_up
+
+	/* Now test for round-to-even */
+	testb	$1,%ebx
+	jz	LCheck_truncate_64
+
+LDo_64_round_up:
+	movb	LOST_UP,FPU_bits_lost
+	addl	$1,%ebx
+	adcl	$0,%eax
+
+LCheck_Round_Overflow:
+	jnc	LRe_normalise		/* Rounding done, no overflow */
+
+	/* Overflow, adjust the result (to 1.0) */
+	rcrl	$1,%eax
+	rcrl	$1,%ebx
+	incl	EXP(%edi)
+	jmp	LRe_normalise
+
+LCheck_truncate_64:
+	orl	%edx,%edx
+	jz	LRe_normalise
+
+LTruncate_64:
+	movb	LOST_DOWN,FPU_bits_lost
+
+LRe_normalise:
+	testb	$0xff,FPU_denormal
+	jnz	xNormalise_result
+
+xL_Normalised:
+	cmpb	LOST_UP,FPU_bits_lost
+	je	xL_precision_lost_up
+
+	cmpb	LOST_DOWN,FPU_bits_lost
+	je	xL_precision_lost_down
+
+xL_no_precision_loss:
+	cmpl	EXP_OVER,EXP(%edi)
+	jge	L_overflow
+
+	/* store the result */
+	movb	TW_Valid,TAG(%edi)
+
+xL_Store_significand:
+	movl	%eax,SIGH(%edi)
+	movl	%ebx,SIGL(%edi)
+
+FPU_Arith_exit:
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+	leave
+	ret
+
+
+/* Set the FPU status flags to represent precision loss due to*/
+/* round-up.*/
+xL_precision_lost_up:
+	push	%eax
+	call	_set_precision_flag_up
+	popl	%eax
+	jmp	xL_no_precision_loss
+
+/* Set the FPU status flags to represent precision loss due to*/
+/* truncation.*/
+xL_precision_lost_down:
+	push	%eax
+	call	_set_precision_flag_down
+	popl	%eax
+	jmp	xL_no_precision_loss
+
+
+/* The number is a denormal (which might get rounded up to a normal)
+// Shift the number right the required number of bits, which will
+// have to be undone later...*/
+xMake_denorm:
+	/* The action to be taken depends upon whether the underflow
+	// exception is masked*/
+	testb	CW_Underflow,%cl		/* Underflow mask.*/
+	jz	xUnmasked_underflow		/* Do not make a denormal.*/
+
+	movb	DENORMAL,FPU_denormal
+
+	pushl	%ecx		/* Save*/
+	movl	EXP(%edi),%ecx
+	subl	EXP_UNDER+1,%ecx
+	negl	%ecx
+
+	cmpl	$64,%ecx	/* shrd only works for 0..31 bits */
+	jnc	xDenorm_shift_more_than_63
+
+	cmpl	$32,%ecx	/* shrd only works for 0..31 bits */
+	jnc	xDenorm_shift_more_than_32
+
+/* We got here without jumps by assuming that the most common requirement
+//   is for a small de-normalising shift.
+// Shift by [1..31] bits */
+	addl	%ecx,EXP(%edi)
+	orl	%edx,%edx	/* extension*/
+	setne	%ch
+	xorl	%edx,%edx
+	shrd	%cl,%ebx,%edx
+	shrd	%cl,%eax,%ebx
+	shr	%cl,%eax
+	orb	%ch,%dl
+	popl	%ecx
+	jmp	xDenorm_done
+
+/* Shift by [32..63] bits*/
+xDenorm_shift_more_than_32:
+	addl	%ecx,EXP(%edi)
+	subb	$32,%cl
+	orl	%edx,%edx
+	setne	%ch
+	orb	%ch,%bl
+	xorl	%edx,%edx
+	shrd	%cl,%ebx,%edx
+	shrd	%cl,%eax,%ebx
+	shr	%cl,%eax
+	orl	%edx,%edx		/*test these 32 bits*/
+	setne	%cl
+	orb	%ch,%bl
+	orb	%cl,%bl
+	movl	%ebx,%edx
+	movl	%eax,%ebx
+	xorl	%eax,%eax
+	popl	%ecx
+	jmp	xDenorm_done
+
+/* Shift by [64..) bits*/
+xDenorm_shift_more_than_63:
+	cmpl	$64,%ecx
+	jne	xDenorm_shift_more_than_64
+
+/* Exactly 64 bit shift*/
+	addl	%ecx,EXP(%edi)
+	xorl	%ecx,%ecx
+	orl	%edx,%edx
+	setne	%cl
+	orl	%ebx,%ebx
+	setne	%ch
+	orb	%ch,%cl
+	orb	%cl,%al
+	movl	%eax,%edx
+	xorl	%eax,%eax
+	xorl	%ebx,%ebx
+	popl	%ecx
+	jmp	xDenorm_done
+
+xDenorm_shift_more_than_64:
+	movl	EXP_UNDER+1,EXP(%edi)
+/* This is easy, %eax must be non-zero, so..*/
+	movl	$1,%edx
+	xorl	%eax,%eax
+	xorl	%ebx,%ebx
+	popl	%ecx
+	jmp	xDenorm_done
+
+
+xUnmasked_underflow:
+	/* Increase the exponent by the magic number*/
+	addl	$(3*(1<<13)),EXP(%edi)
+	movb	UNMASKED_UNDERFLOW,FPU_denormal
+	jmp	xDenorm_done
+
+
+/* Undo the de-normalisation.*/
+xNormalise_result:
+	cmpb	UNMASKED_UNDERFLOW,FPU_denormal
+	je	xSignal_underflow
+
+/* The number must be a denormal if we got here.*/
+#ifdef PARANOID
+	/* But check it... just in case.*/
+	cmpl	EXP_UNDER+1,EXP(%edi)
+	jne	L_norm_bugged
+#endif PARANOID
+
+	orl	%eax,%eax	/* ms bits*/
+	jnz	LNormalise_shift_up_to_31	/* Shift left 0 - 31 bits*/
+
+	orl	%ebx,%ebx
+	jz	L_underflow_to_zero	/* The contents are zero*/
+
+/* Shift left 32 - 63 bits*/
+	movl	%ebx,%eax
+	xorl	%ebx,%ebx
+	subl	$32,EXP(%edi)
+
+LNormalise_shift_up_to_31:
+	bsrl	%eax,%ecx	/* get the required shift in %ecx */
+	subl	$31,%ecx
+	negl	%ecx
+	shld	%cl,%ebx,%eax
+	shl	%cl,%ebx
+	subl	%ecx,EXP(%edi)
+
+LNormalise_shift_done:
+	testb	$0xff,FPU_bits_lost	/* bits lost == underflow*/
+	jz	xL_Normalised
+
+	/* There must be a masked underflow*/
+	push	%eax
+	pushl	EX_Underflow
+	call	_exception
+	popl	%eax
+	popl	%eax
+	jmp	xL_Normalised
+
+
+/* The operations resulted in a number too small to represent.
+// Masked response.*/
+L_underflow_to_zero:
+	push	%eax
+	call	_set_precision_flag_down
+	popl	%eax
+
+	push	%eax
+	pushl	EX_Underflow
+	call	_exception
+	popl	%eax
+	popl	%eax
+
+	movb	TW_Zero,TAG(%edi)
+	jmp	xL_Store_significand
+
+
+/* The operations resulted in a number too large to represent.*/
+L_overflow:
+	push	%edi
+	call	_arith_overflow
+	pop	%edi
+	jmp	FPU_Arith_exit
+
+
+xSignal_underflow:
+	push	%eax
+	pushl	EX_Underflow
+	call	EXCEPTION
+	popl	%eax
+	popl	%eax
+	jmp	xL_Normalised
+
+
+#ifdef PARANOID
+/* If we ever get here then we have problems! */
+L_bugged:
+	pushl	EX_INTERNAL|0x201
+	call	EXCEPTION
+	popl	%ebx
+	jmp	FPU_Arith_exit
+
+L_norm_bugged:
+	pushl	EX_INTERNAL|0x216
+	call	EXCEPTION
+	popl	%ebx
+	jmp	FPU_Arith_exit
+
+L_entry_bugged:
+	pushl	EX_INTERNAL|0x217
+	call	EXCEPTION
+	popl	%ebx
+	jmp	FPU_Arith_exit
+#endif PARANOID
diff --git a/sys/gnu/i386/fpemul/reg_u_add.s b/sys/gnu/i386/fpemul/reg_u_add.s
new file mode 100644
index 0000000..c7d9bfa
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_u_add.s
@@ -0,0 +1,231 @@
+	.file	"reg_u_add.S"
+/*
+ *  reg_u_add.S
+ *
+ * Add two valid (TW_Valid) FPU_REG numbers, of the same sign, and put the
+ *   result in a destination FPU_REG.
+ *
+ * Call from C as:
+ *   void reg_u_add(FPU_REG *arg1, FPU_REG *arg2, FPU_REG *answ,
+ *                                                int control_w)
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+/*
+ |    Kernel addition routine reg_u_add(reg *arg1, reg *arg2, reg *answ).
+ |    Takes two valid reg f.p. numbers (TW_Valid), which are
+ |    treated as unsigned numbers,
+ |    and returns their sum as a TW_Valid or TW_S f.p. number.
+ |    The returned number is normalized.
+ |    Basic checks are performed if PARANOID is defined.
+ */
+
+#include "exception.h"
+#include "fpu_asm.h"
+#include "control_w.h"
+
+.text
+	.align 2,144
+.globl _reg_u_add
+_reg_u_add:
+	pushl	%ebp
+	movl	%esp,%ebp
+/*	subl	$16,%esp*/
+	pushl	%esi
+	pushl	%edi
+	pushl	%ebx
+
+	movl	PARAM1,%esi		/* source 1 */
+	movl	PARAM2,%edi		/* source 2 */
+
+#ifdef DENORM_OPERAND
+	cmpl	EXP_UNDER,EXP(%esi)
+	jg	xOp1_not_denorm
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xOp1_not_denorm:
+	cmpl	EXP_UNDER,EXP(%edi)
+	jg	xOp2_not_denorm
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xOp2_not_denorm:
+#endif DENORM_OPERAND
+
+/*	xorl	%ecx,%ecx*/
+	movl	EXP(%esi),%ecx
+	subl	EXP(%edi),%ecx		/* exp1 - exp2 */
+/*	jnc	L_arg1_larger*/
+	jge	L_arg1_larger
+
+	/* num1 is smaller */
+	movl	SIGL(%esi),%ebx
+	movl	SIGH(%esi),%eax
+
+	movl	%edi,%esi
+	negw	%cx
+	jmp	L_accum_loaded
+
+L_arg1_larger:
+	/* num1 has larger or equal exponent */
+	movl	SIGL(%edi),%ebx
+	movl	SIGH(%edi),%eax
+
+L_accum_loaded:
+	movl	PARAM3,%edi		/* destination */
+	movb	SIGN(%esi),%dl
+	movb	%dl,SIGN(%edi)		/* Copy the sign from the first arg */
+
+
+	movl	EXP(%esi),%edx
+	movl	%edx,EXP(%edi)	/* Copy exponent to destination */
+
+	xorl	%edx,%edx		/* clear the extension */
+
+#ifdef PARANOID
+	testl	$0x80000000,%eax
+	je	L_bugged
+
+	testl	$0x80000000,SIGH(%esi)
+	je	L_bugged
+#endif PARANOID
+
+/* The number to be shifted is in %eax:%ebx:%edx*/
+	cmpw	$32,%cx		/* shrd only works for 0..31 bits */
+	jnc	L_more_than_31
+
+/* less than 32 bits */
+	shrd	%cl,%ebx,%edx
+	shrd	%cl,%eax,%ebx
+	shr	%cl,%eax
+	jmp	L_shift_done
+
+L_more_than_31:
+	cmpw	$64,%cx
+	jnc	L_more_than_63
+
+	subb	$32,%cl
+	jz	L_exactly_32
+
+	shrd	%cl,%eax,%edx
+	shr	%cl,%eax
+	orl	%ebx,%ebx
+	jz	L_more_31_no_low	/* none of the lowest bits is set*/
+
+	orl	$1,%edx			/* record the fact in the extension*/
+
+L_more_31_no_low:
+	movl	%eax,%ebx
+	xorl	%eax,%eax
+	jmp	L_shift_done
+
+L_exactly_32:
+	movl	%ebx,%edx
+	movl	%eax,%ebx
+	xorl	%eax,%eax
+	jmp	L_shift_done
+
+L_more_than_63:
+	cmpw	$65,%cx
+	jnc	L_more_than_64
+
+	movl	%eax,%edx
+	orl	%ebx,%ebx
+	jz	L_more_63_no_low
+
+	orl	$1,%edx
+	jmp	L_more_63_no_low
+
+L_more_than_64:
+	movl	$1,%edx		/* The shifted nr always at least one '1'*/
+
+L_more_63_no_low:
+	xorl	%ebx,%ebx
+	xorl	%eax,%eax
+
+L_shift_done:
+	/* Now do the addition */
+	addl	SIGL(%esi),%ebx
+	adcl	SIGH(%esi),%eax
+	jnc	L_round_the_result
+
+	/* Overflow, adjust the result */
+	rcrl	$1,%eax
+	rcrl	$1,%ebx
+	rcrl	$1,%edx
+	jnc	L_no_bit_lost
+
+	orl	$1,%edx
+
+L_no_bit_lost:
+	incl	EXP(%edi)
+
+L_round_the_result:
+	jmp	FPU_round	/* Round the result*/
+
+
+
+#ifdef PARANOID
+/* If we ever get here then we have problems! */
+L_bugged:
+	pushl	EX_INTERNAL|0x201
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+#endif PARANOID
+
+
+L_exit:
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+	leave
+	ret
diff --git a/sys/gnu/i386/fpemul/reg_u_div.s b/sys/gnu/i386/fpemul/reg_u_div.s
new file mode 100644
index 0000000..9a87ff6
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_u_div.s
@@ -0,0 +1,493 @@
+	.file	"reg_u_div.S"
+/*
+ *  reg_u_div.S
+ *
+ * Core division routines
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*---------------------------------------------------------------------------+
+ |  Kernel for the division routines.                                        |
+ |                                                                           |
+ |  void reg_u_div(FPU_REG *a, FPU_REG *a,                                   |
+ |                 FPU_REG *dest, unsigned int control_word)                 |
+ |                                                                           |
+ |  Does not compute the destination exponent, but does adjust it.           |
+ +---------------------------------------------------------------------------*/
+
+#include "exception.h"
+#include "fpu_asm.h"
+#include "control_w.h"
+
+
+/* #define	dSIGL(x)	(x) */
+/* #define	dSIGH(x)	4(x) */
+
+
+.data
+/*
+	Local storage:
+	Result:		accum_3:accum_2:accum_1:accum_0
+	Overflow flag:	ovfl_flag
+ */
+	.align 2,0
+accum_3:
+	.long	0
+accum_2:
+	.long	0
+accum_1:
+	.long	0
+accum_0:
+	.long	0
+result_1:
+	.long	0
+result_2:
+	.long	0
+ovfl_flag:
+	.byte	0
+
+
+.text
+	.align 2,144
+
+.globl _reg_u_div
+
+.globl _divide_kernel
+
+_reg_u_div:
+	pushl	%ebp
+	movl	%esp,%ebp
+
+	pushl	%esi
+	pushl	%edi
+	pushl	%ebx
+
+	movl	PARAM1,%esi	/* pointer to num */
+	movl	PARAM2,%ebx	/* pointer to denom */
+	movl	PARAM3,%edi	/* pointer to answer */
+
+#ifdef DENORM_OPERAND
+	movl	EXP(%esi),%eax
+	cmpl	EXP_UNDER,%eax
+	jg	xOp1_not_denorm
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xOp1_not_denorm:
+	movl	EXP(%ebx),%eax
+	cmpl	EXP_UNDER,%eax
+	jg	xOp2_not_denorm
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xOp2_not_denorm:
+#endif DENORM_OPERAND
+
+_divide_kernel:
+#ifdef PARANOID
+/*	testl	$0x80000000, SIGH(%esi)	*//* Dividend */
+/*	je	L_bugged */
+	testl	$0x80000000, SIGH(%ebx)	/* Divisor*/
+	je	L_bugged
+#endif PARANOID
+
+/* Check if the divisor can be treated as having just 32 bits */
+	cmpl	$0,SIGL(%ebx)
+	jnz	L_Full_Division	/* Can't do a quick divide */
+
+/* We should be able to zip through the division here */
+	movl	SIGH(%ebx),%ecx	/* The divisor */
+	movl	SIGH(%esi),%edx	/* Dividend */
+	movl	SIGL(%esi),%eax	/* Dividend */
+
+	cmpl	%ecx,%edx
+	setaeb	ovfl_flag	/* Keep a record */
+	jb	L_no_adjust
+
+	subl	%ecx,%edx	/* Prevent the overflow */
+
+L_no_adjust:
+	/* Divide the 64 bit number by the 32 bit denominator */
+	divl	%ecx
+	movl	%eax,result_2
+
+	/* Work on the remainder of the first division */
+	xorl	%eax,%eax
+	divl	%ecx
+	movl	%eax,result_1
+
+	/* Work on the remainder of the 64 bit division */
+	xorl	%eax,%eax
+	divl	%ecx
+
+	testb	$255,ovfl_flag	/* was the num > denom ? */
+	je	L_no_overflow
+
+	/* Do the shifting here */
+	/* increase the exponent */
+	incl	EXP(%edi)
+
+	/* shift the mantissa right one bit */
+	stc			/* To set the ms bit */
+	rcrl	result_2
+	rcrl	result_1
+	rcrl	%eax
+
+L_no_overflow:
+	jmp	LRound_precision	/* Do the rounding as required*/
+
+
+/*---------------------------------------------------------------------------+
+ |  Divide:   Return  arg1/arg2 to arg3.                                     |
+ |                                                                           |
+ |  This routine does not use the exponents of arg1 and arg2, but does       |
+ |  adjust the exponent of arg3.                                             |
+ |                                                                           |
+ |  The maximum returned value is (ignoring exponents)                       |
+ |               .ffffffff ffffffff                                          |
+ |               ------------------  =  1.ffffffff fffffffe                  |
+ |               .80000000 00000000                                          |
+ | and the minimum is                                                        |
+ |               .80000000 00000000                                          |
+ |               ------------------  =  .80000000 00000001   (rounded)       |
+ |               .ffffffff ffffffff                                          |
+ |                                                                           |
+ +---------------------------------------------------------------------------*/
+
+
+L_Full_Division:
+	/* Save extended dividend in local register*/
+	movl	SIGL(%esi),%eax
+	movl	%eax,accum_2
+	movl	SIGH(%esi),%eax
+	movl	%eax,accum_3
+	xorl	%eax,%eax
+	movl	%eax,accum_1	/* zero the extension */
+	movl	%eax,accum_0	/* zero the extension */
+
+	movl	SIGL(%esi),%eax	/* Get the current num */
+	movl	SIGH(%esi),%edx
+
+/*----------------------------------------------------------------------*/
+/* Initialization done */
+/* Do the first 32 bits */
+
+	movb	$0,ovfl_flag
+	cmpl	SIGH(%ebx),%edx	/* Test for imminent overflow */
+	jb	LLess_than_1
+	ja	LGreater_than_1
+
+	cmpl	SIGL(%ebx),%eax
+	jb	LLess_than_1
+
+LGreater_than_1:
+/* The dividend is greater or equal, would cause overflow */
+	setaeb	ovfl_flag		/* Keep a record */
+
+	subl	SIGL(%ebx),%eax
+	sbbl	SIGH(%ebx),%edx	/* Prevent the overflow */
+	movl	%eax,accum_2
+	movl	%edx,accum_3
+
+LLess_than_1:
+/* At this point, we have a dividend < divisor, with a record of
+   adjustment in ovfl_flag */
+
+	/* We will divide by a number which is too large */
+	movl	SIGH(%ebx),%ecx
+	addl	$1,%ecx
+	jnc	LFirst_div_not_1
+
+	/* here we need to divide by 100000000h,
+	   i.e., no division at all.. */
+	mov	%edx,%eax
+	jmp	LFirst_div_done
+
+LFirst_div_not_1:
+	divl	%ecx		/* Divide the numerator by the augmented
+				   denom ms dw */
+
+LFirst_div_done:
+	movl	%eax,result_2	/* Put the result in the answer */
+
+	mull	SIGH(%ebx)	/* mul by the ms dw of the denom */
+
+	subl	%eax,accum_2	/* Subtract from the num local reg */
+	sbbl	%edx,accum_3
+
+	movl	result_2,%eax	/* Get the result back */
+	mull	SIGL(%ebx)	/* now mul the ls dw of the denom */
+
+	subl	%eax,accum_1	/* Subtract from the num local reg */
+	sbbl	%edx,accum_2
+	sbbl	$0,accum_3
+	je	LDo_2nd_32_bits		/* Must check for non-zero result here */
+
+#ifdef PARANOID
+	jb	L_bugged_1
+#endif PARANOID
+
+	/* need to subtract another once of the denom */
+	incl	result_2	/* Correct the answer */
+
+	movl	SIGL(%ebx),%eax
+	movl	SIGH(%ebx),%edx
+	subl	%eax,accum_1	/* Subtract from the num local reg */
+	sbbl	%edx,accum_2
+
+#ifdef PARANOID
+	sbbl	$0,accum_3
+	jne	L_bugged_1	/* Must check for non-zero result here */
+#endif PARANOID
+
+/*----------------------------------------------------------------------*/
+/* Half of the main problem is done, there is just a reduced numerator
+   to handle now */
+/* Work with the second 32 bits, accum_0 not used from now on */
+LDo_2nd_32_bits:
+	movl	accum_2,%edx	/* get the reduced num */
+	movl	accum_1,%eax
+
+	/* need to check for possible subsequent overflow */
+	cmpl	SIGH(%ebx),%edx
+	jb	LDo_2nd_div
+	ja	LPrevent_2nd_overflow
+
+	cmpl	SIGL(%ebx),%eax
+	jb	LDo_2nd_div
+
+LPrevent_2nd_overflow:
+/* The numerator is greater or equal, would cause overflow */
+	/* prevent overflow */
+	subl	SIGL(%ebx),%eax
+	sbbl	SIGH(%ebx),%edx
+	movl	%edx,accum_2
+	movl	%eax,accum_1
+
+	incl	result_2	/* Reflect the subtraction in the answer */
+
+#ifdef PARANOID
+	je	L_bugged_2	/* Can't bump the result to 1.0 */
+#endif PARANOID
+
+LDo_2nd_div:
+	cmpl	$0,%ecx		/* augmented denom msw*/
+	jnz	LSecond_div_not_1
+
+	/* %ecx == 0, we are dividing by 1.0 */
+	mov	%edx,%eax
+	jmp	LSecond_div_done
+
+LSecond_div_not_1:
+	divl	%ecx		/* Divide the numerator by the denom ms dw */
+
+LSecond_div_done:
+	movl	%eax,result_1	/* Put the result in the answer */
+
+	mull	SIGH(%ebx)	/* mul by the ms dw of the denom */
+
+	subl	%eax,accum_1	/* Subtract from the num local reg */
+	sbbl	%edx,accum_2
+
+#ifdef PARANOID
+	jc	L_bugged_2
+#endif PARANOID
+
+	movl	result_1,%eax	/* Get the result back */
+	mull	SIGL(%ebx)	/* now mul the ls dw of the denom */
+
+	subl	%eax,accum_0	/* Subtract from the num local reg */
+	sbbl	%edx,accum_1	/* Subtract from the num local reg */
+	sbbl	$0,accum_2
+
+#ifdef PARANOID
+	jc	L_bugged_2
+#endif PARANOID
+
+	jz	LDo_3rd_32_bits
+
+#ifdef PARANOID
+	cmpl	$1,accum_2
+	jne	L_bugged_2
+#endif PARANOID
+
+	/* need to subtract another once of the denom */
+	movl	SIGL(%ebx),%eax
+	movl	SIGH(%ebx),%edx
+	subl	%eax,accum_0	/* Subtract from the num local reg */
+	sbbl	%edx,accum_1
+	sbbl	$0,accum_2
+
+#ifdef PARANOID
+	jc	L_bugged_2
+	jne	L_bugged_2
+#endif PARANOID
+
+	addl	$1,result_1	/* Correct the answer */
+	adcl	$0,result_2
+
+#ifdef PARANOID
+	jc	L_bugged_2	/* Must check for non-zero result here */
+#endif PARANOID
+
+/*----------------------------------------------------------------------*/
+/* The division is essentially finished here, we just need to perform
+   tidying operations. */
+/* deal with the 3rd 32 bits */
+LDo_3rd_32_bits:
+	movl	accum_1,%edx		/* get the reduced num */
+	movl	accum_0,%eax
+
+	/* need to check for possible subsequent overflow */
+	cmpl	SIGH(%ebx),%edx	/* denom*/
+	jb	LRound_prep
+	ja	LPrevent_3rd_overflow
+
+	cmpl	SIGL(%ebx),%eax	/* denom */
+	jb	LRound_prep
+
+LPrevent_3rd_overflow:
+	/* prevent overflow */
+	subl	SIGL(%ebx),%eax
+	sbbl	SIGH(%ebx),%edx
+	movl	%edx,accum_1
+	movl	%eax,accum_0
+
+	addl	$1,result_1	/* Reflect the subtraction in the answer */
+	adcl	$0,result_2
+	jne	LRound_prep
+	jnc	LRound_prep
+
+	/* This is a tricky spot, there is an overflow of the answer */
+	movb	$255,ovfl_flag		/* Overflow -> 1.000 */
+
+LRound_prep:
+/* Prepare for rounding.
+// To test for rounding, we just need to compare 2*accum with the
+// denom. */
+	movl	accum_0,%ecx
+	movl	accum_1,%edx
+	movl	%ecx,%eax
+	orl	%edx,%eax
+	jz	LRound_ovfl		/* The accumulator contains zero.*/
+
+	/* Multiply by 2 */
+	clc
+	rcll	$1,%ecx
+	rcll	$1,%edx
+	jc	LRound_large		/* No need to compare, denom smaller */
+
+	subl	SIGL(%ebx),%ecx
+	sbbl	SIGH(%ebx),%edx
+	jnc	LRound_not_small
+
+	movl	$0x70000000,%eax	/* Denom was larger */
+	jmp	LRound_ovfl
+
+LRound_not_small:
+	jnz	LRound_large
+
+	movl	$0x80000000,%eax	/* Remainder was exactly 1/2 denom */
+	jmp	LRound_ovfl
+
+LRound_large:
+	movl	$0xff000000,%eax	/* Denom was smaller */
+
+LRound_ovfl:
+/* We are now ready to deal with rounding, but first we must get
+   the bits properly aligned */
+	testb	$255,ovfl_flag	/* was the num > denom ? */
+	je	LRound_precision
+
+	incl	EXP(%edi)
+
+	/* shift the mantissa right one bit */
+	stc			/* Will set the ms bit */
+	rcrl	result_2
+	rcrl	result_1
+	rcrl	%eax
+
+/* Round the result as required */
+LRound_precision:
+	decl	EXP(%edi)	/* binary point between 1st & 2nd bits */
+
+	movl	%eax,%edx
+	movl	result_1,%ebx
+	movl	result_2,%eax
+	jmp	FPU_round
+
+
+#ifdef PARANOID
+/* The logic is wrong if we got here */
+L_bugged:
+	pushl	EX_INTERNAL|0x202
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+
+L_bugged_1:
+	pushl	EX_INTERNAL|0x203
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+
+L_bugged_2:
+	pushl	EX_INTERNAL|0x204
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+
+L_exit:
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+
+	leave
+	ret
+#endif PARANOID
diff --git a/sys/gnu/i386/fpemul/reg_u_mul.s b/sys/gnu/i386/fpemul/reg_u_mul.s
new file mode 100644
index 0000000..8b36e7c
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_u_mul.s
@@ -0,0 +1,186 @@
+	.file	"reg_u_mul.S"
+/*
+ *  reg_u_mul.S
+ *
+ * Core multiplication routine
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*---------------------------------------------------------------------------+
+ |   Basic multiplication routine.                                           |
+ |   Does not check the resulting exponent for overflow/underflow            |
+ |                                                                           |
+ |   reg_u_mul(FPU_REG *a, FPU_REG *b, FPU_REG *c, unsigned int cw);         |
+ |                                                                           |
+ |   Internal working is at approx 128 bits.                                 |
+ |   Result is rounded to nearest 53 or 64 bits, using "nearest or even".    |
+ +---------------------------------------------------------------------------*/
+
+#include "exception.h"
+#include "fpu_asm.h"
+#include "control_w.h"
+
+
+.data
+	.align 2,0
+accum_0:
+	.long	0
+accum_1:
+	.long	0
+
+
+.text
+	.align 2,144
+
+.globl _reg_u_mul
+_reg_u_mul:
+	pushl	%ebp
+	movl	%esp,%ebp
+	pushl	%esi
+	pushl	%edi
+	pushl	%ebx
+
+	movl	PARAM1,%esi
+	movl	PARAM2,%edi
+
+#ifdef PARANOID
+	testl	$0x80000000,SIGH(%esi)
+	jz	L_bugged
+	testl	$0x80000000,SIGH(%edi)
+	jz	L_bugged
+#endif PARANOID
+
+#ifdef DENORM_OPERAND
+	movl	EXP(%esi),%eax
+	cmpl	EXP_UNDER,%eax
+	jg	xOp1_not_denorm
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xOp1_not_denorm:
+	movl	EXP(%edi),%eax
+	cmpl	EXP_UNDER,%eax
+	jg	xOp2_not_denorm
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xOp2_not_denorm:
+#endif DENORM_OPERAND
+
+	xorl	%ecx,%ecx
+	xorl	%ebx,%ebx
+
+	movl	SIGL(%esi),%eax
+	mull	SIGL(%edi)
+	movl	%eax,accum_0
+	movl	%edx,accum_1
+
+	movl	SIGL(%esi),%eax
+	mull	SIGH(%edi)
+	addl	%eax,accum_1
+	adcl	%edx,%ebx
+/*	adcl	$0,%ecx		*//* overflow here is not possible */
+
+	movl	SIGH(%esi),%eax
+	mull	SIGL(%edi)
+	addl	%eax,accum_1
+	adcl	%edx,%ebx
+	adcl	$0,%ecx
+
+	movl	SIGH(%esi),%eax
+	mull	SIGH(%edi)
+	addl	%eax,%ebx
+	adcl	%edx,%ecx
+
+	movl	EXP(%esi),%eax	/* Compute the exponent */
+	addl	EXP(%edi),%eax
+	subl	EXP_BIAS-1,%eax
+/*  Have now finished with the sources */
+	movl	PARAM3,%edi	/* Point to the destination */
+	movl	%eax,EXP(%edi)
+
+/*  Now make sure that the result is normalized */
+	testl	$0x80000000,%ecx
+	jnz	LResult_Normalised
+
+	/* Normalize by shifting left one bit */
+	shll	$1,accum_0
+	rcll	$1,accum_1
+	rcll	$1,%ebx
+	rcll	$1,%ecx
+	decl	EXP(%edi)
+
+LResult_Normalised:
+	movl	accum_0,%eax
+	movl	accum_1,%edx
+	orl	%eax,%eax
+	jz	L_extent_zero
+
+	orl	$1,%edx
+
+L_extent_zero:
+	movl	%ecx,%eax
+	jmp	FPU_round
+
+
+#ifdef PARANOID
+L_bugged:
+	pushl	EX_INTERNAL|0x205
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+
+L_exit:
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+	leave
+	ret
+#endif PARANOID
+
diff --git a/sys/gnu/i386/fpemul/reg_u_sub.s b/sys/gnu/i386/fpemul/reg_u_sub.s
new file mode 100644
index 0000000..8a7d2d9
--- /dev/null
+++ b/sys/gnu/i386/fpemul/reg_u_sub.s
@@ -0,0 +1,348 @@
+	.file	"reg_u_sub.S"
+/*
+ *  reg_u_sub.S
+ *
+ * Core floating point subtraction routine.
+ *
+ * Call from C as:
+ *   void reg_u_sub(FPU_REG *arg1, FPU_REG *arg2, FPU_REG *answ,
+ *                                                int control_w)
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*
+ |    Kernel subtraction routine reg_u_sub(reg *arg1, reg *arg2, reg *answ).
+ |    Takes two valid reg f.p. numbers (TW_Valid), which are
+ |    treated as unsigned numbers,
+ |    and returns their difference as a TW_Valid or TW_Zero f.p.
+ |    number.
+ |    The first number (arg1) must be the larger.
+ |    The returned number is normalized.
+ |    Basic checks are performed if PARANOID is defined.
+ */
+
+#include "exception.h"
+#include "fpu_asm.h"
+#include "control_w.h"
+
+.text
+	.align 2,144
+.globl _reg_u_sub
+_reg_u_sub:
+	pushl	%ebp
+	movl	%esp,%ebp
+	pushl	%esi
+	pushl	%edi
+	pushl	%ebx
+
+	movl	PARAM1,%esi	/* source 1 */
+	movl	PARAM2,%edi	/* source 2 */
+
+#ifdef DENORM_OPERAND
+	cmpl	EXP_UNDER,EXP(%esi)
+	jg	xOp1_not_denorm
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xOp1_not_denorm:
+	cmpl	EXP_UNDER,EXP(%edi)
+	jg	xOp2_not_denorm
+
+	call	_denormal_operand
+	orl	%eax,%eax
+	jnz	FPU_Arith_exit
+
+xOp2_not_denorm:
+#endif DENORM_OPERAND
+
+/*	xorl	%ecx,%ecx */
+	movl	EXP(%esi),%ecx
+	subl	EXP(%edi),%ecx	/* exp1 - exp2 */
+
+#ifdef PARANOID
+	/* source 2 is always smaller than source 1 */
+/*	jc	L_bugged */
+	js	L_bugged_1
+
+	testl	$0x80000000,SIGH(%edi)	/* The args are assumed to be be normalized */
+	je	L_bugged_2
+
+	testl	$0x80000000,SIGH(%esi)
+	je	L_bugged_2
+#endif PARANOID
+
+/*--------------------------------------+
+ |	Form a register holding the     |
+ |	smaller number                  |
+ +--------------------------------------*/
+	movl	SIGH(%edi),%eax	/* register ms word */
+	movl	SIGL(%edi),%ebx	/* register ls word */
+
+	movl	PARAM3,%edi	/* destination */
+	movl	EXP(%esi),%edx
+	movl	%edx,EXP(%edi)	/* Copy exponent to destination */
+	movb	SIGN(%esi),%dl
+	movb	%dl,SIGN(%edi)	/* Copy the sign from the first arg */
+
+	xorl	%edx,%edx	/* register extension */
+
+/*--------------------------------------+
+ |	Shift the temporary register	|
+ |      right the required number of	|
+ |	places.				|
+ +--------------------------------------*/
+L_shift_r:
+	cmpl	$32,%ecx		/* shrd only works for 0..31 bits */
+	jnc	L_more_than_31
+
+/* less than 32 bits */
+	shrd	%cl,%ebx,%edx
+	shrd	%cl,%eax,%ebx
+	shr	%cl,%eax
+	jmp	L_shift_done
+
+L_more_than_31:
+	cmpl	$64,%ecx
+	jnc	L_more_than_63
+
+	subb	$32,%cl
+	jz	L_exactly_32
+
+	shrd	%cl,%eax,%edx
+	shr	%cl,%eax
+	orl	%ebx,%ebx
+	jz	L_more_31_no_low	/* none of the lowest bits is set */
+
+	orl	$1,%edx			/* record the fact in the extension */
+
+L_more_31_no_low:
+	movl	%eax,%ebx
+	xorl	%eax,%eax
+	jmp	L_shift_done
+
+L_exactly_32:
+	movl	%ebx,%edx
+	movl	%eax,%ebx
+	xorl	%eax,%eax
+	jmp	L_shift_done
+
+L_more_than_63:
+	cmpw	$65,%cx
+	jnc	L_more_than_64
+
+	/* Shift right by 64 bits */
+	movl	%eax,%edx
+	orl	%ebx,%ebx
+	jz	L_more_63_no_low
+
+	orl	$1,%edx
+	jmp	L_more_63_no_low
+
+L_more_than_64:
+	jne	L_more_than_65
+
+	/* Shift right by 65 bits */
+	/* Carry is clear if we get here */
+	movl	%eax,%edx
+	rcrl	%edx
+	jnc	L_shift_65_nc
+
+	orl	$1,%edx
+	jmp	L_more_63_no_low
+
+L_shift_65_nc:
+	orl	%ebx,%ebx
+	jz	L_more_63_no_low
+
+	orl	$1,%edx
+	jmp	L_more_63_no_low
+
+L_more_than_65:
+	movl	$1,%edx		/* The shifted nr always at least one '1' */
+
+L_more_63_no_low:
+	xorl	%ebx,%ebx
+	xorl	%eax,%eax
+
+L_shift_done:
+L_subtr:
+/*------------------------------+
+ |	Do the subtraction	|
+ +------------------------------*/
+	xorl	%ecx,%ecx
+	subl	%edx,%ecx
+	movl	%ecx,%edx
+	movl	SIGL(%esi),%ecx
+	sbbl	%ebx,%ecx
+	movl	%ecx,%ebx
+	movl	SIGH(%esi),%ecx
+	sbbl	%eax,%ecx
+	movl	%ecx,%eax
+
+#ifdef PARANOID
+	/* We can never get a borrow */
+	jc	L_bugged
+#endif PARANOID
+
+/*--------------------------------------+
+ |	Normalize the result		|
+ +--------------------------------------*/
+	testl	$0x80000000,%eax
+	jnz	L_round		/* no shifting needed */
+
+	orl	%eax,%eax
+	jnz	L_shift_1	/* shift left 1 - 31 bits */
+
+	orl	%ebx,%ebx
+	jnz	L_shift_32	/* shift left 32 - 63 bits */
+
+/*	 A rare case, the only one which is non-zero if we got here
+//         is:           1000000 .... 0000
+//                      -0111111 .... 1111 1
+//                       -------------------- 
+//                       0000000 .... 0000 1  */
+
+	cmpl	$0x80000000,%edx
+	jnz	L_must_be_zero
+
+	/* Shift left 64 bits */
+	subl	$64,EXP(%edi)
+	movl	%edx,%eax
+	jmp	L_store
+
+L_must_be_zero:
+#ifdef PARANOID
+	orl	%edx,%edx
+	jnz	L_bugged_3
+#endif PARANOID
+
+	/* The result is zero */
+	movb	TW_Zero,TAG(%edi)
+	movl	$0,EXP(%edi)		/* exponent */
+	movl	$0,SIGL(%edi)
+	movl	$0,SIGH(%edi)
+	jmp	L_exit		/* Does not underflow */
+
+L_shift_32:
+	movl	%ebx,%eax
+	movl	%edx,%ebx
+	movl	$0,%edx
+	subl	$32,EXP(%edi)	/* Can get underflow here */
+
+/* We need to shift left by 1 - 31 bits */
+L_shift_1:
+	bsrl	%eax,%ecx	/* get the required shift in %ecx */
+	subl	$31,%ecx
+	negl	%ecx
+	shld	%cl,%ebx,%eax
+	shld	%cl,%edx,%ebx
+	shl	%cl,%edx
+	subl	%ecx,EXP(%edi)	/* Can get underflow here */
+
+L_round:
+	jmp	FPU_round	/* Round the result */
+
+
+#ifdef PARANOID
+L_bugged_1:
+	pushl	EX_INTERNAL|0x206
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+
+L_bugged_2:
+	pushl	EX_INTERNAL|0x209
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+
+L_bugged_3:
+	pushl	EX_INTERNAL|0x210
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+
+L_bugged_4:
+	pushl	EX_INTERNAL|0x211
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+
+L_bugged:
+	pushl	EX_INTERNAL|0x212
+	call	EXCEPTION
+	pop	%ebx
+	jmp	L_exit
+#endif PARANOID
+
+
+L_store:
+/*------------------------------+
+ |	Store the result	|
+ +------------------------------*/
+	movl	%eax,SIGH(%edi)
+	movl	%ebx,SIGL(%edi)
+
+	movb	TW_Valid,TAG(%edi)		/* Set the tags to TW_Valid */
+
+	cmpl	EXP_UNDER,EXP(%edi)
+	jle	L_underflow
+
+L_exit:
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+	leave
+	ret
+
+
+L_underflow:
+	push	%edi
+	call	_arith_underflow
+	pop	%ebx
+	jmp	L_exit
+
diff --git a/sys/gnu/i386/fpemul/status_w.h b/sys/gnu/i386/fpemul/status_w.h
new file mode 100644
index 0000000..4526f38
--- /dev/null
+++ b/sys/gnu/i386/fpemul/status_w.h
@@ -0,0 +1,93 @@
+/*
+ *  status_w.h
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#ifndef _STATUS_H_
+#define _STATUS_H_
+
+
+#ifdef LOCORE
+#define	Const__(x)	$/**/x
+#else
+#define	Const__(x)	x
+#endif
+
+#define SW_Backward    	Const__(0x8000)	/* backward compatibility */
+#define SW_C3		Const__(0x4000)	/* condition bit 3 */
+#define SW_Top		Const__(0x3800)	/* top of stack */
+#define SW_Top_Shift 	Const__(11)	/* shift for top of stack bits */
+#define SW_C2		Const__(0x0400)	/* condition bit 2 */
+#define SW_C1		Const__(0x0200)	/* condition bit 1 */
+#define SW_C0		Const__(0x0100)	/* condition bit 0 */
+#define SW_Summary     	Const__(0x0080)	/* exception summary */
+#define SW_Stack_Fault	Const__(0x0040)	/* stack fault */
+#define SW_Precision   	Const__(0x0020)	/* loss of precision */
+#define SW_Underflow   	Const__(0x0010)	/* underflow */
+#define SW_Overflow    	Const__(0x0008)	/* overflow */
+#define SW_Zero_Div    	Const__(0x0004)	/* divide by zero */
+#define SW_Denorm_Op   	Const__(0x0002)	/* denormalized operand */
+#define SW_Invalid     	Const__(0x0001)	/* invalid operation */
+
+#define SW_Exc_Mask     Const__(0x27f)	/* Status word exception bit mask */
+
+#ifndef LOCORE
+
+#define COMP_A_gt_B	1
+#define COMP_A_eq_B	2
+#define COMP_A_lt_B	3
+#define COMP_No_Comp	4
+#define COMP_Denormal   0x20
+#define COMP_NaN	0x40
+#define COMP_SNaN	0x80
+
+#define setcc(cc) ({ \
+  status_word &= ~(SW_C0|SW_C1|SW_C2|SW_C3); \
+  status_word |= (cc) & (SW_C0|SW_C1|SW_C2|SW_C3); })
+
+#endif				/* LOCORE */
+
+#endif				/* _STATUS_H_ */
diff --git a/sys/gnu/i386/fpemul/version.h b/sys/gnu/i386/fpemul/version.h
new file mode 100644
index 0000000..201de20
--- /dev/null
+++ b/sys/gnu/i386/fpemul/version.h
@@ -0,0 +1,48 @@
+/*
+ *  version.h
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define FPU_VERSION "wm-FPU-emu version BETA 1.4"
diff --git a/sys/gnu/i386/fpemul/wm_shrx.s b/sys/gnu/i386/fpemul/wm_shrx.s
new file mode 100644
index 0000000..08f6223
--- /dev/null
+++ b/sys/gnu/i386/fpemul/wm_shrx.s
@@ -0,0 +1,248 @@
+	.file	"wm_shrx.S"
+/*
+ *  wm_shrx.S
+ *
+ * 64 bit right shift functions
+ *
+ * Call from C as:
+ *   unsigned shrx(void *arg1, unsigned arg2)
+ * and
+ *   unsigned shrxs(void *arg1, unsigned arg2)
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include "fpu_asm.h"
+
+.text
+	.align 2,144
+
+/*---------------------------------------------------------------------------+
+ |   unsigned shrx(void *arg1, unsigned arg2)                                |
+ |                                                                           |
+ |   Extended shift right function.                                          |
+ |   Fastest for small shifts.                                               |
+ |   Shifts the 64 bit quantity pointed to by the first arg (arg1)           |
+ |   right by the number of bits specified by the second arg (arg2).         |
+ |   Forms a 96 bit quantity from the 64 bit arg and eax:                    |
+ |                [  64 bit arg ][ eax ]                                     |
+ |            shift right  --------->                                        |
+ |   The eax register is initialized to 0 before the shifting.               |
+ |   Results returned in the 64 bit arg and eax.                             |
+ +---------------------------------------------------------------------------*/
+
+	.globl	_shrx
+
+_shrx:
+	push	%ebp
+	movl	%esp,%ebp
+	pushl	%esi
+	movl	PARAM2,%ecx
+	movl	PARAM1,%esi
+	cmpl	$32,%ecx	/* shrd only works for 0..31 bits */
+	jnc	L_more_than_31
+
+/* less than 32 bits */
+	pushl	%ebx
+	movl	(%esi),%ebx	/* lsl */
+	movl	4(%esi),%edx	/* msl */
+	xorl	%eax,%eax	/* extension */
+	shrd	%cl,%ebx,%eax
+	shrd	%cl,%edx,%ebx
+	shr	%cl,%edx
+	movl	%ebx,(%esi)
+	movl	%edx,4(%esi)
+	popl	%ebx
+	popl	%esi
+	leave
+	ret
+
+L_more_than_31:
+	cmpl	$64,%ecx
+	jnc	L_more_than_63
+
+	subb	$32,%cl
+	movl	(%esi),%eax	/* lsl */
+	movl	4(%esi),%edx	/* msl */
+	shrd	%cl,%edx,%eax
+	shr	%cl,%edx
+	movl	%edx,(%esi)
+	movl	$0,4(%esi)
+	popl	%esi
+	leave
+	ret
+
+L_more_than_63:
+	cmpl	$96,%ecx
+	jnc	L_more_than_95
+
+	subb	$64,%cl
+	movl	4(%esi),%eax	/* msl */
+	shr	%cl,%eax
+	xorl	%edx,%edx
+	movl	%edx,(%esi)
+	movl	%edx,4(%esi)
+	popl	%esi
+	leave
+	ret
+
+L_more_than_95:
+	xorl	%eax,%eax
+	movl	%eax,(%esi)
+	movl	%eax,4(%esi)
+	popl	%esi
+	leave
+	ret
+
+
+/*---------------------------------------------------------------------------+
+ |   unsigned shrxs(void *arg1, unsigned arg2)                               |
+ |                                                                           |
+ |   Extended shift right function (optimized for small floating point       |
+ |   integers).                                                              |
+ |   Shifts the 64 bit quantity pointed to by the first arg (arg1)           |
+ |   right by the number of bits specified by the second arg (arg2).         |
+ |   Forms a 96 bit quantity from the 64 bit arg and eax:                    |
+ |                [  64 bit arg ][ eax ]                                     |
+ |            shift right  --------->                                        |
+ |   The eax register is initialized to 0 before the shifting.               |
+ |   The lower 8 bits of eax are lost and replaced by a flag which is        |
+ |   set (to 0x01) if any bit, apart from the first one, is set in the       |
+ |   part which has been shifted out of the arg.                             |
+ |   Results returned in the 64 bit arg and eax.                             |
+ +---------------------------------------------------------------------------*/
+	.globl	_shrxs
+_shrxs:
+	push	%ebp
+	movl	%esp,%ebp
+	pushl	%esi
+	pushl	%ebx
+	movl	PARAM2,%ecx
+	movl	PARAM1,%esi
+	cmpl	$64,%ecx	/* shrd only works for 0..31 bits */
+	jnc	Ls_more_than_63
+
+	cmpl	$32,%ecx	/* shrd only works for 0..31 bits */
+	jc	Ls_less_than_32
+
+/* We got here without jumps by assuming that the most common requirement
+   is for small integers */
+/* Shift by [32..63] bits */
+	subb	$32,%cl
+	movl	(%esi),%eax	/* lsl */
+	movl	4(%esi),%edx	/* msl */
+	xorl	%ebx,%ebx
+	shrd	%cl,%eax,%ebx
+	shrd	%cl,%edx,%eax
+	shr	%cl,%edx
+	orl	%ebx,%ebx		/* test these 32 bits */
+	setne	%bl
+	test	$0x7fffffff,%eax	/* and 31 bits here */
+	setne	%bh
+	orw	%bx,%bx			/* Any of the 63 bit set ? */
+	setne	%al
+	movl	%edx,(%esi)
+	movl	$0,4(%esi)
+	popl	%ebx
+	popl	%esi
+	leave
+	ret
+
+/* Shift by [0..31] bits */
+Ls_less_than_32:
+	movl	(%esi),%ebx	/* lsl */
+	movl	4(%esi),%edx	/* msl */
+	xorl	%eax,%eax	/* extension */
+	shrd	%cl,%ebx,%eax
+	shrd	%cl,%edx,%ebx
+	shr	%cl,%edx
+	test	$0x7fffffff,%eax	/* only need to look at eax here */
+	setne	%al
+	movl	%ebx,(%esi)
+	movl	%edx,4(%esi)
+	popl	%ebx
+	popl	%esi
+	leave
+	ret
+
+/* Shift by [64..95] bits */
+Ls_more_than_63:
+	cmpl	$96,%ecx
+	jnc	Ls_more_than_95
+
+	subb	$64,%cl
+	movl	(%esi),%ebx	/* lsl */
+	movl	4(%esi),%eax	/* msl */
+	xorl	%edx,%edx	/* extension */
+	shrd	%cl,%ebx,%edx
+	shrd	%cl,%eax,%ebx
+	shr	%cl,%eax
+	orl	%ebx,%edx
+	setne	%bl
+	test	$0x7fffffff,%eax	/* only need to look at eax here */
+	setne	%bh
+	orw	%bx,%bx
+	setne	%al
+	xorl	%edx,%edx
+	movl	%edx,(%esi)	/* set to zero */
+	movl	%edx,4(%esi)	/* set to zero */
+	popl	%ebx
+	popl	%esi
+	leave
+	ret
+
+Ls_more_than_95:
+/* Shift by [96..inf) bits */
+	xorl	%eax,%eax
+	movl	(%esi),%ebx
+	orl	4(%esi),%ebx
+	setne	%al
+	xorl	%ebx,%ebx
+	movl	%ebx,(%esi)
+	movl	%ebx,4(%esi)
+	popl	%ebx
+	popl	%esi
+	leave
+	ret
diff --git a/sys/gnu/i386/fpemul/wm_sqrt.s b/sys/gnu/i386/fpemul/wm_sqrt.s
new file mode 100644
index 0000000..a28a92f
--- /dev/null
+++ b/sys/gnu/i386/fpemul/wm_sqrt.s
@@ -0,0 +1,483 @@
+	.file	"wm_sqrt.S"
+/*
+ *  wm_sqrt.S
+ *
+ * Fixed point arithmetic square root evaluation.
+ *
+ * Call from C as:
+ *   void wm_sqrt(FPU_REG *n, unsigned int control_word)
+ *
+ *
+ * Copyright (C) 1992, 1993  W. Metzenthen, 22 Parker St, Ormond,
+ *                           Vic 3163, Australia.
+ *                           E-mail apm233m@vaxc.cc.monash.edu.au
+ * All rights reserved.
+ *
+ * This copyright notice covers the redistribution and use of the
+ * FPU emulator developed by W. Metzenthen. It covers only its use
+ * in the 386BSD operating system. Any other use is not permitted
+ * under this copyright.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must include information specifying
+ *    that source code for the emulator is freely available and include
+ *    either:
+ *      a) an offer to provide the source code for a nominal distribution
+ *         fee, or
+ *      b) list at least two alternative methods whereby the source
+ *         can be obtained, e.g. a publically accessible bulletin board
+ *         and an anonymous ftp site from which the software can be
+ *         downloaded.
+ * 3. All advertising materials specifically mentioning features or use of
+ *    this emulator must acknowledge that it was developed by W. Metzenthen.
+ * 4. The name of W. Metzenthen may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * W. METZENTHEN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+/*---------------------------------------------------------------------------+
+ |  wm_sqrt(FPU_REG *n, unsigned int control_word)                           |
+ |    returns the square root of n in n.                                     |
+ |                                                                           |
+ |  Use Newton's method to compute the square root of a number, which must   |
+ |  be in the range  [1.0 .. 4.0),  to 64 bits accuracy.                     |
+ |  Does not check the sign or tag of the argument.                          |
+ |  Sets the exponent, but not the sign or tag of the result.                |
+ |                                                                           |
+ |  The guess is kept in %esi:%edi                                           |
+ +---------------------------------------------------------------------------*/
+
+#include "exception.h"
+#include "fpu_asm.h"
+
+
+.data
+/*
+	Local storage:
+ */
+	.align 4,0
+accum_3:
+	.long	0		/* ms word */
+accum_2:
+	.long	0
+accum_1:
+	.long	0
+accum_0:
+	.long	0
+
+/* The de-normalised argument:
+//                  sq_2                  sq_1              sq_0
+//        b b b b b b b ... b b b   b b b .... b b b   b 0 0 0 ... 0
+//           ^ binary point here */
+fsqrt_arg_2:
+	.long	0		/* ms word */
+fsqrt_arg_1:
+	.long	0
+fsqrt_arg_0:
+	.long	0		/* ls word, at most the ms bit is set */
+
+.text
+	.align 2,144
+
+.globl _wm_sqrt
+
+_wm_sqrt:
+	pushl	%ebp
+	movl	%esp,%ebp
+	pushl	%esi
+	pushl	%edi
+	pushl	%ebx
+
+	movl	PARAM1,%esi
+
+	movl	SIGH(%esi),%eax
+	movl	SIGL(%esi),%ecx
+	xorl	%edx,%edx
+
+/* We use a rough linear estimate for the first guess.. */
+
+	cmpl	EXP_BIAS,EXP(%esi)
+	jnz	sqrt_arg_ge_2
+
+	shrl	$1,%eax			/* arg is in the range  [1.0 .. 2.0) */
+	rcrl	$1,%ecx
+	rcrl	$1,%edx
+
+sqrt_arg_ge_2:
+/* From here on, n is never accessed directly again until it is
+// replaced by the answer. */
+
+	movl	%eax,fsqrt_arg_2		/* ms word of n */
+	movl	%ecx,fsqrt_arg_1
+	movl	%edx,fsqrt_arg_0
+
+/* Make a linear first estimate */
+	shrl	$1,%eax
+	addl	$0x40000000,%eax
+	movl	$0xaaaaaaaa,%ecx
+	mull	%ecx
+	shll	%edx			/* max result was 7fff... */
+	testl	$0x80000000,%edx	/* but min was 3fff... */
+	jnz	sqrt_prelim_no_adjust
+
+	movl	$0x80000000,%edx	/* round up */
+
+sqrt_prelim_no_adjust:
+	movl	%edx,%esi	/* Our first guess */
+
+/* We have now computed (approx)   (2 + x) / 3, which forms the basis
+   for a few iterations of Newton's method */
+
+	movl	fsqrt_arg_2,%ecx	/* ms word */
+
+/* From our initial estimate, three iterations are enough to get us
+// to 30 bits or so. This will then allow two iterations at better
+// precision to complete the process.
+
+// Compute  (g + n/g)/2  at each iteration (g is the guess). */
+	shrl	%ecx		/* Doing this first will prevent a divide */
+				/* overflow later. */
+
+	movl	%ecx,%edx	/* msw of the arg / 2 */
+	divl	%esi		/* current estimate */
+	shrl	%esi		/* divide by 2 */
+	addl	%eax,%esi	/* the new estimate */
+
+	movl	%ecx,%edx
+	divl	%esi
+	shrl	%esi
+	addl	%eax,%esi
+
+	movl	%ecx,%edx
+	divl	%esi
+	shrl	%esi
+	addl	%eax,%esi
+
+/* Now that an estimate accurate to about 30 bits has been obtained (in %esi),
+// we improve it to 60 bits or so.
+
+// The strategy from now on is to compute new estimates from
+//      guess := guess + (n - guess^2) / (2 * guess) */
+
+/* First, find the square of the guess */
+	movl	%esi,%eax
+	mull	%esi
+/* guess^2 now in %edx:%eax */
+
+	movl	fsqrt_arg_1,%ecx
+	subl	%ecx,%eax
+	movl	fsqrt_arg_2,%ecx	/* ms word of normalized n */
+	sbbl	%ecx,%edx
+	jnc	sqrt_stage_2_positive
+/* subtraction gives a negative result
+// negate the result before division */
+	notl	%edx
+	notl	%eax
+	addl	$1,%eax
+	adcl	$0,%edx
+
+	divl	%esi
+	movl	%eax,%ecx
+
+	movl	%edx,%eax
+	divl	%esi
+	jmp	sqrt_stage_2_finish
+
+sqrt_stage_2_positive:
+	divl	%esi
+	movl	%eax,%ecx
+
+	movl	%edx,%eax
+	divl	%esi
+
+	notl	%ecx
+	notl	%eax
+	addl	$1,%eax
+	adcl	$0,%ecx
+
+sqrt_stage_2_finish:
+	sarl	$1,%ecx		/* divide by 2 */
+	rcrl	$1,%eax
+
+	/* Form the new estimate in %esi:%edi */
+	movl	%eax,%edi
+	addl	%ecx,%esi
+
+	jnz	sqrt_stage_2_done	/* result should be [1..2) */
+
+#ifdef PARANOID
+/* It should be possible to get here only if the arg is ffff....ffff*/
+	cmp	$0xffffffff,fsqrt_arg_1
+	jnz	sqrt_stage_2_error
+#endif PARANOID
+
+/* The best rounded result.*/
+	xorl	%eax,%eax
+	decl	%eax
+	movl	%eax,%edi
+	movl	%eax,%esi
+	movl	$0x7fffffff,%eax
+	jmp	sqrt_round_result
+
+#ifdef PARANOID
+sqrt_stage_2_error:
+	pushl	EX_INTERNAL|0x213
+	call	EXCEPTION
+#endif PARANOID
+
+sqrt_stage_2_done:
+
+/* Now the square root has been computed to better than 60 bits */
+
+/* Find the square of the guess*/
+	movl	%edi,%eax		/* ls word of guess*/
+	mull	%edi
+	movl	%edx,accum_1
+
+	movl	%esi,%eax
+	mull	%esi
+	movl	%edx,accum_3
+	movl	%eax,accum_2
+
+	movl	%edi,%eax
+	mull	%esi
+	addl	%eax,accum_1
+	adcl	%edx,accum_2
+	adcl	$0,accum_3
+
+/*	movl	%esi,%eax*/
+/*	mull	%edi*/
+	addl	%eax,accum_1
+	adcl	%edx,accum_2
+	adcl	$0,accum_3
+
+/* guess^2 now in accum_3:accum_2:accum_1*/
+
+	movl	fsqrt_arg_0,%eax		/* get normalized n*/
+	subl	%eax,accum_1
+	movl	fsqrt_arg_1,%eax
+	sbbl	%eax,accum_2
+	movl	fsqrt_arg_2,%eax		/* ms word of normalized n*/
+	sbbl	%eax,accum_3
+	jnc	sqrt_stage_3_positive
+
+/* subtraction gives a negative result*/
+/* negate the result before division */
+	notl	accum_1
+	notl	accum_2
+	notl	accum_3
+	addl	$1,accum_1
+	adcl	$0,accum_2
+
+#ifdef PARANOID
+	adcl	$0,accum_3	/* This must be zero */
+	jz	sqrt_stage_3_no_error
+
+sqrt_stage_3_error:
+	pushl	EX_INTERNAL|0x207
+	call	EXCEPTION
+
+sqrt_stage_3_no_error:
+#endif PARANOID
+
+	movl	accum_2,%edx
+	movl	accum_1,%eax
+	divl	%esi
+	movl	%eax,%ecx
+
+	movl	%edx,%eax
+	divl	%esi
+
+	sarl	$1,%ecx		/ divide by 2*/
+	rcrl	$1,%eax
+
+	/* prepare to round the result*/
+
+	addl	%ecx,%edi
+	adcl	$0,%esi
+
+	jmp	sqrt_stage_3_finished
+
+sqrt_stage_3_positive:
+	movl	accum_2,%edx
+	movl	accum_1,%eax
+	divl	%esi
+	movl	%eax,%ecx
+
+	movl	%edx,%eax
+	divl	%esi
+
+	sarl	$1,%ecx		/* divide by 2*/
+	rcrl	$1,%eax
+
+	/* prepare to round the result*/
+
+	notl	%eax		/* Negate the correction term*/
+	notl	%ecx
+	addl	$1,%eax
+	adcl	$0,%ecx		/* carry here ==> correction == 0*/
+	adcl	$0xffffffff,%esi
+
+	addl	%ecx,%edi
+	adcl	$0,%esi
+
+sqrt_stage_3_finished:
+
+/* The result in %esi:%edi:%esi should be good to about 90 bits here,
+// and the rounding information here does not have sufficient accuracy
+// in a few rare cases. */
+	cmpl	$0xffffffe0,%eax
+	ja	sqrt_near_exact_x
+
+	cmpl	$0x00000020,%eax
+	jb	sqrt_near_exact
+
+	cmpl	$0x7fffffe0,%eax
+	jb	sqrt_round_result
+
+	cmpl	$0x80000020,%eax
+	jb	sqrt_get_more_precision
+
+sqrt_round_result:
+/* Set up for rounding operations*/
+	movl	%eax,%edx
+	movl	%esi,%eax
+	movl	%edi,%ebx
+	movl	PARAM1,%edi
+	movl	EXP_BIAS,EXP(%edi)	/* Result is in  [1.0 .. 2.0)*/
+	movl	PARAM2,%ecx
+	jmp	FPU_round_sqrt
+
+
+sqrt_near_exact_x:
+/* First, the estimate must be rounded up.*/
+	addl	$1,%edi
+	adcl	$0,%esi
+
+sqrt_near_exact:
+/* This is an easy case because x^1/2 is monotonic.
+// We need just find the square of our estimate, compare it
+// with the argument, and deduce whether our estimate is
+// above, below, or exact. We use the fact that the estimate
+// is known to be accurate to about 90 bits. */
+	movl	%edi,%eax		/* ls word of guess*/
+	mull	%edi
+	movl	%edx,%ebx		/* 2nd ls word of square*/
+	movl	%eax,%ecx		/* ls word of square*/
+
+	movl	%edi,%eax
+	mull	%esi
+	addl	%eax,%ebx
+	addl	%eax,%ebx
+
+#ifdef PARANOID
+	cmp	$0xffffffb0,%ebx
+	jb	sqrt_near_exact_ok
+
+	cmp	$0x00000050,%ebx
+	ja	sqrt_near_exact_ok
+
+	pushl	EX_INTERNAL|0x214
+	call	EXCEPTION
+
+sqrt_near_exact_ok:
+#endif PARANOID
+
+	or	%ebx,%ebx
+	js	sqrt_near_exact_small
+
+	jnz	sqrt_near_exact_large
+
+	or	%ebx,%edx
+	jnz	sqrt_near_exact_large
+
+/* Our estimate is exactly the right answer*/
+	xorl	%eax,%eax
+	jmp	sqrt_round_result
+
+sqrt_near_exact_small:
+/* Our estimate is too small*/
+	movl	$0x000000ff,%eax
+	jmp	sqrt_round_result
+	
+sqrt_near_exact_large:
+/* Our estimate is too large, we need to decrement it*/
+	subl	$1,%edi
+	sbbl	$0,%esi
+	movl	$0xffffff00,%eax
+	jmp	sqrt_round_result
+
+
+sqrt_get_more_precision:
+/* This case is almost the same as the above, except we start*/
+/* with an extra bit of precision in the estimate.*/
+	stc			/* The extra bit.*/
+	rcll	$1,%edi		/* Shift the estimate left one bit*/
+	rcll	$1,%esi
+
+	movl	%edi,%eax		/* ls word of guess*/
+	mull	%edi
+	movl	%edx,%ebx		/* 2nd ls word of square*/
+	movl	%eax,%ecx		/* ls word of square*/
+
+	movl	%edi,%eax
+	mull	%esi
+	addl	%eax,%ebx
+	addl	%eax,%ebx
+
+/* Put our estimate back to its original value*/
+	stc			/* The ms bit.*/
+	rcrl	$1,%esi		/* Shift the estimate left one bit*/
+	rcrl	$1,%edi
+
+#ifdef PARANOID
+	cmp	$0xffffff60,%ebx
+	jb	sqrt_more_prec_ok
+
+	cmp	$0x000000a0,%ebx
+	ja	sqrt_more_prec_ok
+
+	pushl	EX_INTERNAL|0x215
+	call	EXCEPTION
+
+sqrt_more_prec_ok:
+#endif PARANOID
+
+	or	%ebx,%ebx
+	js	sqrt_more_prec_small
+
+	jnz	sqrt_more_prec_large
+
+	or	%ebx,%ecx
+	jnz	sqrt_more_prec_large
+
+/* Our estimate is exactly the right answer*/
+	movl	$0x80000000,%eax
+	jmp	sqrt_round_result
+
+sqrt_more_prec_small:
+/* Our estimate is too small*/
+	movl	$0x800000ff,%eax
+	jmp	sqrt_round_result
+	
+sqrt_more_prec_large:
+/* Our estimate is too large*/
+	movl	$0x7fffff00,%eax
+	jmp	sqrt_round_result