Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
  • 2 commits
  • 5 files changed
  • 0 comments
  • 1 contributor
144  software/libbase/milieu.h
... ...
@@ -1,9 +1,8 @@
1 1
 
2  
-/*
3  
-===============================================================================
  2
+/*============================================================================
4 3
 
5  
-This C header file is part of the SoftFloat IEC/IEEE Floating-point
6  
-Arithmetic Package, Release 2.
  4
+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
  5
+Package, Release 2b.
7 6
 
8 7
 Written by John R. Hauser.  This work was made possible in part by the
9 8
 International Computer Science Institute, located at Suite 600, 1947 Center
@@ -12,54 +11,48 @@ National Science Foundation under grant MIP-9311980.  The original version
12 11
 of this code was written as part of a project to build a fixed-point vector
13 12
 processor in collaboration with the University of California at Berkeley,
14 13
 overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
15  
-is available through the Web page `http://http.cs.berkeley.edu/~jhauser/
16  
-arithmetic/softfloat.html'.
  14
+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
  15
+arithmetic/SoftFloat.html'.
17 16
 
18  
-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
19  
-has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
20  
-TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
21  
-PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
22  
-AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
  17
+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
  18
+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
  19
+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
  20
+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
  21
+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
  22
+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
  23
+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
  24
+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
23 25
 
24 26
 Derivative works are acceptable, even for commercial purposes, so long as
25  
-(1) they include prominent notice that the work is derivative, and (2) they
26  
-include prominent notice akin to these three paragraphs for those parts of
27  
-this code that are retained.
28  
-
29  
-===============================================================================
30  
-*/
31  
-
32  
-/*
33  
--------------------------------------------------------------------------------
34  
-Common integer types and flags.
35  
--------------------------------------------------------------------------------
36  
-*/
37  
-
38  
-/*
39  
--------------------------------------------------------------------------------
40  
-One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
41  
--------------------------------------------------------------------------------
42  
-*/
  27
+(1) the source code for the derivative work includes prominent notice that
  28
+the work is derivative, and (2) the source code includes prominent notice with
  29
+these four paragraphs for those parts of this code that are retained.
  30
+
  31
+=============================================================================*/
  32
+
  33
+/*----------------------------------------------------------------------------
  34
+| Include common integer types and flags.
  35
+*----------------------------------------------------------------------------*/
  36
+
  37
+/*----------------------------------------------------------------------------
  38
+| One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
  39
+*----------------------------------------------------------------------------*/
43 40
 #define BIGENDIAN
44 41
 
45  
-/*
46  
--------------------------------------------------------------------------------
47  
-The macro `BITS64' can be defined to indicate that 64-bit integer types are
48  
-supported by the compiler.
49  
--------------------------------------------------------------------------------
50  
-*/
  42
+/*----------------------------------------------------------------------------
  43
+| The macro `BITS64' can be defined to indicate that 64-bit integer types are
  44
+| supported by the compiler.
  45
+*----------------------------------------------------------------------------*/
51 46
 //#define BITS64
52 47
 
53  
-/*
54  
--------------------------------------------------------------------------------
55  
-Each of the following `typedef's defines the most convenient type that holds
56  
-integers of at least as many bits as specified.  For example, `uint8' should
57  
-be the most convenient type that can hold unsigned integers of as many as
58  
-8 bits.  The `flag' type must be able to hold either a 0 or 1.  For most
59  
-implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
60  
-to the same as `int'.
61  
--------------------------------------------------------------------------------
62  
-*/
  48
+/*----------------------------------------------------------------------------
  49
+| Each of the following `typedef's defines the most convenient type that holds
  50
+| integers of at least as many bits as specified.  For example, `uint8' should
  51
+| be the most convenient type that can hold unsigned integers of as many as
  52
+| 8 bits.  The `flag' type must be able to hold either a 0 or 1.  For most
  53
+| implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
  54
+| to the same as `int'.
  55
+*----------------------------------------------------------------------------*/
63 56
 typedef int flag;
64 57
 typedef int uint8;
65 58
 typedef int int8;
@@ -68,18 +61,16 @@ typedef int int16;
68 61
 typedef unsigned int uint32;
69 62
 typedef signed int int32;
70 63
 #ifdef BITS64
71  
-typedef unsigned long long int bits64;
72  
-typedef signed long long int sbits64;
  64
+typedef unsigned long long int uint64;
  65
+typedef signed long long int int64;
73 66
 #endif
74 67
 
75  
-/*
76  
--------------------------------------------------------------------------------
77  
-Each of the following `typedef's defines a type that holds integers
78  
-of _exactly_ the number of bits specified.  For instance, for most
79  
-implementation of C, `bits16' and `sbits16' should be `typedef'ed to
80  
-`unsigned short int' and `signed short int' (or `short int'), respectively.
81  
--------------------------------------------------------------------------------
82  
-*/
  68
+/*----------------------------------------------------------------------------
  69
+| Each of the following `typedef's defines a type that holds integers
  70
+| of _exactly_ the number of bits specified.  For instance, for most
  71
+| implementation of C, `bits16' and `sbits16' should be `typedef'ed to
  72
+| `unsigned short int' and `signed short int' (or `short int'), respectively.
  73
+*----------------------------------------------------------------------------*/
83 74
 typedef unsigned char bits8;
84 75
 typedef signed char sbits8;
85 76
 typedef unsigned short int bits16;
@@ -87,38 +78,33 @@ typedef signed short int sbits16;
87 78
 typedef unsigned int bits32;
88 79
 typedef signed int sbits32;
89 80
 #ifdef BITS64
90  
-typedef unsigned long long int uint64;
91  
-typedef signed long long int int64;
  81
+typedef unsigned long long int bits64;
  82
+typedef signed long long int sbits64;
92 83
 #endif
93 84
 
94 85
 #ifdef BITS64
95  
-/*
96  
--------------------------------------------------------------------------------
97  
-The `LIT64' macro takes as its argument a textual integer literal and if
98  
-necessary ``marks'' the literal as having a 64-bit integer type.  For
99  
-example, the Gnu C Compiler (`gcc') requires that 64-bit literals be
100  
-appended with the letters `LL' standing for `long long', which is `gcc's
101  
-name for the 64-bit integer type.  Some compilers may allow `LIT64' to be
102  
-defined as the identity macro:  `#define LIT64( a ) a'.
103  
--------------------------------------------------------------------------------
104  
-*/
  86
+/*----------------------------------------------------------------------------
  87
+| The `LIT64' macro takes as its argument a textual integer literal and
  88
+| if necessary ``marks'' the literal as having a 64-bit integer type.
  89
+| For example, the GNU C Compiler (`gcc') requires that 64-bit literals be
  90
+| appended with the letters `LL' standing for `long long', which is `gcc's
  91
+| name for the 64-bit integer type.  Some compilers may allow `LIT64' to be
  92
+| defined as the identity macro:  `#define LIT64( a ) a'.
  93
+*----------------------------------------------------------------------------*/
105 94
 #define LIT64( a ) a##LL
106 95
 #endif
107 96
 
108  
-/*
109  
--------------------------------------------------------------------------------
110  
-The macro `INLINE' can be used before functions that should be inlined.  If
111  
-a compiler does not support explicit inlining, this macro should be defined
112  
-to be `static'.
113  
--------------------------------------------------------------------------------
114  
-*/
  97
+/*----------------------------------------------------------------------------
  98
+| The macro `INLINE' can be used before functions that should be inlined.  If
  99
+| a compiler does not support explicit inlining, this macro should be defined
  100
+| to be `static'.
  101
+*----------------------------------------------------------------------------*/
115 102
 #define INLINE extern inline
116 103
 
117  
-/*
118  
--------------------------------------------------------------------------------
119  
-Symbolic Boolean literals.
120  
--------------------------------------------------------------------------------
121  
-*/
  104
+
  105
+/*----------------------------------------------------------------------------
  106
+| Symbolic Boolean literals.
  107
+*----------------------------------------------------------------------------*/
122 108
 enum {
123 109
     FALSE = 0,
124 110
     TRUE  = 1
1,273  software/libbase/softfloat-macros.h
... ...
@@ -1,646 +1,627 @@
1  
-
2  
-/*
3  
-===============================================================================
4  
-
5  
-This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
6  
-Arithmetic Package, Release 2.
7  
-
8  
-Written by John R. Hauser.  This work was made possible in part by the
9  
-International Computer Science Institute, located at Suite 600, 1947 Center
10  
-Street, Berkeley, California 94704.  Funding was partially provided by the
11  
-National Science Foundation under grant MIP-9311980.  The original version
12  
-of this code was written as part of a project to build a fixed-point vector
13  
-processor in collaboration with the University of California at Berkeley,
14  
-overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
15  
-is available through the web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
16  
-arithmetic/softfloat.html'.
17  
-
18  
-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
19  
-has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
20  
-TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
21  
-PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
22  
-AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
23  
-
24  
-Derivative works are acceptable, even for commercial purposes, so long as
25  
-(1) they include prominent notice that the work is derivative, and (2) they
26  
-include prominent notice akin to these three paragraphs for those parts of
27  
-this code that are retained.
28  
-
29  
-===============================================================================
30  
-*/
31  
-
32  
-/*
33  
--------------------------------------------------------------------------------
34  
-Shifts `a' right by the number of bits given in `count'.  If any nonzero
35  
-bits are shifted off, they are ``jammed'' into the least significant bit of
36  
-the result by setting the least significant bit to 1.  The value of `count'
37  
-can be arbitrarily large; in particular, if `count' is greater than 32, the
38  
-result will be either 0 or 1, depending on whether `a' is zero or nonzero.
39  
-The result is stored in the location pointed to by `zPtr'.
40  
--------------------------------------------------------------------------------
41  
-*/
42  
-INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr )
43  
-{
44  
-    bits32 z;
45  
-
46  
-    if ( count == 0 ) {
47  
-        z = a;
48  
-    }
49  
-    else if ( count < 32 ) {
50  
-        z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );
51  
-    }
52  
-    else {
53  
-        z = ( a != 0 );
54  
-    }
55  
-    *zPtr = z;
56  
-
57  
-}
58  
-
59  
-/*
60  
--------------------------------------------------------------------------------
61  
-Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the
62  
-number of bits given in `count'.  Any bits shifted off are lost.  The value
63  
-of `count' can be arbitrarily large; in particular, if `count' is greater
64  
-than 64, the result will be 0.  The result is broken into two 32-bit pieces
65  
-which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
66  
--------------------------------------------------------------------------------
67  
-*/
68  
-INLINE void
69  
- shift64Right(
70  
-     bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr )
71  
-{
72  
-    bits32 z0, z1;
73  
-    int8 negCount = ( - count ) & 31;
74  
-
75  
-    if ( count == 0 ) {
76  
-        z1 = a1;
77  
-        z0 = a0;
78  
-    }
79  
-    else if ( count < 32 ) {
80  
-        z1 = ( a0<<negCount ) | ( a1>>count );
81  
-        z0 = a0>>count;
82  
-    }
83  
-    else {
84  
-        z1 = ( count < 64 ) ? ( a0>>( count & 31 ) ) : 0;
85  
-        z0 = 0;
86  
-    }
87  
-    *z1Ptr = z1;
88  
-    *z0Ptr = z0;
89  
-
90  
-}
91  
-
92  
-/*
93  
--------------------------------------------------------------------------------
94  
-Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the
95  
-number of bits given in `count'.  If any nonzero bits are shifted off, they
96  
-are ``jammed'' into the least significant bit of the result by setting the
97  
-least significant bit to 1.  The value of `count' can be arbitrarily large;
98  
-in particular, if `count' is greater than 64, the result will be either 0
99  
-or 1, depending on whether the concatenation of `a0' and `a1' is zero or
100  
-nonzero.  The result is broken into two 32-bit pieces which are stored at
101  
-the locations pointed to by `z0Ptr' and `z1Ptr'.
102  
--------------------------------------------------------------------------------
103  
-*/
104  
-INLINE void
105  
- shift64RightJamming(
106  
-     bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr )
107  
-{
108  
-    bits32 z0, z1;
109  
-    int8 negCount = ( - count ) & 31;
110  
-
111  
-    if ( count == 0 ) {
112  
-        z1 = a1;
113  
-        z0 = a0;
114  
-    }
115  
-    else if ( count < 32 ) {
116  
-        z1 = ( a0<<negCount ) | ( a1>>count ) | ( ( a1<<negCount ) != 0 );
117  
-        z0 = a0>>count;
118  
-    }
119  
-    else {
120  
-        if ( count == 32 ) {
121  
-            z1 = a0 | ( a1 != 0 );
122  
-        }
123  
-        else if ( count < 64 ) {
124  
-            z1 = ( a0>>( count & 31 ) ) | ( ( ( a0<<negCount ) | a1 ) != 0 );
125  
-        }
126  
-        else {
127  
-            z1 = ( ( a0 | a1 ) != 0 );
128  
-        }
129  
-        z0 = 0;
130  
-    }
131  
-    *z1Ptr = z1;
132  
-    *z0Ptr = z0;
133  
-
134  
-}
135  
-
136  
-/*
137  
--------------------------------------------------------------------------------
138  
-Shifts the 96-bit value formed by concatenating `a0', `a1', and `a2' right
139  
-by 32 _plus_ the number of bits given in `count'.  The shifted result is
140  
-at most 64 nonzero bits; these are broken into two 32-bit pieces which are
141  
-stored at the locations pointed to by `z0Ptr' and `z1Ptr'.  The bits shifted
142  
-off form a third 32-bit result as follows:  The _last_ bit shifted off is
143  
-the most-significant bit of the extra result, and the other 31 bits of the
144  
-extra result are all zero if and only if _all_but_the_last_ bits shifted off
145  
-were all zero.  This extra result is stored in the location pointed to by
146  
-`z2Ptr'.  The value of `count' can be arbitrarily large.
147  
-    (This routine makes more sense if `a0', `a1', and `a2' are considered
148  
-to form a fixed-point value with binary point between `a1' and `a2'.  This
149  
-fixed-point value is shifted right by the number of bits given in `count',
150  
-and the integer part of the result is returned at the locations pointed to
151  
-by `z0Ptr' and `z1Ptr'.  The fractional part of the result may be slightly
152  
-corrupted as described above, and is returned at the location pointed to by
153  
-`z2Ptr'.)
154  
--------------------------------------------------------------------------------
155  
-*/
156  
-INLINE void
157  
- shift64ExtraRightJamming(
158  
-     bits32 a0,
159  
-     bits32 a1,
160  
-     bits32 a2,
161  
-     int16 count,
162  
-     bits32 *z0Ptr,
163  
-     bits32 *z1Ptr,
164  
-     bits32 *z2Ptr
165  
- )
166  
-{
167  
-    bits32 z0, z1, z2;
168  
-    int8 negCount = ( - count ) & 31;
169  
-
170  
-    if ( count == 0 ) {
171  
-        z2 = a2;
172  
-        z1 = a1;
173  
-        z0 = a0;
174  
-    }
175  
-    else {
176  
-        if ( count < 32 ) {
177  
-            z2 = a1<<negCount;
178  
-            z1 = ( a0<<negCount ) | ( a1>>count );
179  
-            z0 = a0>>count;
180  
-        }
181  
-        else {
182  
-            if ( count == 32 ) {
183  
-                z2 = a1;
184  
-                z1 = a0;
185  
-            }
186  
-            else {
187  
-                a2 |= a1;
188  
-                if ( count < 64 ) {
189  
-                    z2 = a0<<negCount;
190  
-                    z1 = a0>>( count & 31 );
191  
-                }
192  
-                else {
193  
-                    z2 = ( count == 64 ) ? a0 : ( a0 != 0 );
194  
-                    z1 = 0;
195  
-                }
196  
-            }
197  
-            z0 = 0;
198  
-        }
199  
-        z2 |= ( a2 != 0 );
200  
-    }
201  
-    *z2Ptr = z2;
202  
-    *z1Ptr = z1;
203  
-    *z0Ptr = z0;
204  
-
205  
-}
206  
-
207  
-/*
208  
--------------------------------------------------------------------------------
209  
-Shifts the 64-bit value formed by concatenating `a0' and `a1' left by the
210  
-number of bits given in `count'.  Any bits shifted off are lost.  The value
211  
-of `count' must be less than 32.  The result is broken into two 32-bit
212  
-pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
213  
--------------------------------------------------------------------------------
214  
-*/
215  
-INLINE void
216  
- shortShift64Left(
217  
-     bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr )
218  
-{
219  
-
220  
-    *z1Ptr = a1<<count;
221  
-    *z0Ptr =
222  
-        ( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 31 ) );
223  
-
224  
-}
225  
-
226  
-/*
227  
--------------------------------------------------------------------------------
228  
-Shifts the 96-bit value formed by concatenating `a0', `a1', and `a2' left by
229  
-the number of bits given in `count'.  Any bits shifted off are lost.  The
230  
-value of `count' must be less than 32.  The result is broken into three
231  
-32-bit pieces which are stored at the locations pointed to by `z0Ptr',
232  
-`z1Ptr', and `z2Ptr'.
233  
--------------------------------------------------------------------------------
234  
-*/
235  
-INLINE void
236  
- shortShift96Left(
237  
-     bits32 a0,
238  
-     bits32 a1,
239  
-     bits32 a2,
240  
-     int16 count,
241  
-     bits32 *z0Ptr,
242  
-     bits32 *z1Ptr,
243  
-     bits32 *z2Ptr
244  
- )
245  
-{
246  
-    bits32 z0, z1, z2;
247  
-    int8 negCount;
248  
-
249  
-    z2 = a2<<count;
250  
-    z1 = a1<<count;
251  
-    z0 = a0<<count;
252  
-    if ( 0 < count ) {
253  
-        negCount = ( ( - count ) & 31 );
254  
-        z1 |= a2>>negCount;
255  
-        z0 |= a1>>negCount;
256  
-    }
257  
-    *z2Ptr = z2;
258  
-    *z1Ptr = z1;
259  
-    *z0Ptr = z0;
260  
-
261  
-}
262  
-
263  
-/*
264  
--------------------------------------------------------------------------------
265  
-Adds the 64-bit value formed by concatenating `a0' and `a1' to the 64-bit
266  
-value formed by concatenating `b0' and `b1'.  Addition is modulo 2^64, so
267  
-any carry out is lost.  The result is broken into two 32-bit pieces which
268  
-are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
269  
--------------------------------------------------------------------------------
270  
-*/
271  
-INLINE void
272  
- add64(
273  
-     bits32 a0, bits32 a1, bits32 b0, bits32 b1, bits32 *z0Ptr, bits32 *z1Ptr )
274  
-{
275  
-    bits32 z1;
276  
-
277  
-    z1 = a1 + b1;
278  
-    *z1Ptr = z1;
279  
-    *z0Ptr = a0 + b0 + ( z1 < a1 );
280  
-
281  
-}
282  
-
283  
-/*
284  
--------------------------------------------------------------------------------
285  
-Adds the 96-bit value formed by concatenating `a0', `a1', and `a2' to the
286  
-96-bit value formed by concatenating `b0', `b1', and `b2'.  Addition is
287  
-modulo 2^96, so any carry out is lost.  The result is broken into three
288  
-32-bit pieces which are stored at the locations pointed to by `z0Ptr',
289  
-`z1Ptr', and `z2Ptr'.
290  
--------------------------------------------------------------------------------
291  
-*/
292  
-INLINE void
293  
- add96(
294  
-     bits32 a0,
295  
-     bits32 a1,
296  
-     bits32 a2,
297  
-     bits32 b0,
298  
-     bits32 b1,
299  
-     bits32 b2,
300  
-     bits32 *z0Ptr,
301  
-     bits32 *z1Ptr,
302  
-     bits32 *z2Ptr
303  
- )
304  
-{
305  
-    bits32 z0, z1, z2;
306  
-    int8 carry0, carry1;
307  
-
308  
-    z2 = a2 + b2;
309  
-    carry1 = ( z2 < a2 );
310  
-    z1 = a1 + b1;
311  
-    carry0 = ( z1 < a1 );
312  
-    z0 = a0 + b0;
313  
-    z1 += carry1;
314  
-    z0 += ( z1 < carry1 );
315  
-    z0 += carry0;
316  
-    *z2Ptr = z2;
317  
-    *z1Ptr = z1;
318  
-    *z0Ptr = z0;
319  
-
320  
-}
321  
-
322  
-/*
323  
--------------------------------------------------------------------------------
324  
-Subtracts the 64-bit value formed by concatenating `b0' and `b1' from the
325  
-64-bit value formed by concatenating `a0' and `a1'.  Subtraction is modulo
326  
-2^64, so any borrow out (carry out) is lost.  The result is broken into two
327  
-32-bit pieces which are stored at the locations pointed to by `z0Ptr' and
328  
-`z1Ptr'.
329  
--------------------------------------------------------------------------------
330  
-*/
331  
-INLINE void
332  
- sub64(
333  
-     bits32 a0, bits32 a1, bits32 b0, bits32 b1, bits32 *z0Ptr, bits32 *z1Ptr )
334  
-{
335  
-
336  
-    *z1Ptr = a1 - b1;
337  
-    *z0Ptr = a0 - b0 - ( a1 < b1 );
338  
-
339  
-}
340  
-
341  
-/*
342  
--------------------------------------------------------------------------------
343  
-Subtracts the 96-bit value formed by concatenating `b0', `b1', and `b2' from
344  
-the 96-bit value formed by concatenating `a0', `a1', and `a2'.  Subtraction
345  
-is modulo 2^96, so any borrow out (carry out) is lost.  The result is broken
346  
-into three 32-bit pieces which are stored at the locations pointed to by
347  
-`z0Ptr', `z1Ptr', and `z2Ptr'.
348  
--------------------------------------------------------------------------------
349  
-*/
350  
-INLINE void
351  
- sub96(
352  
-     bits32 a0,
353  
-     bits32 a1,
354  
-     bits32 a2,
355  
-     bits32 b0,
356  
-     bits32 b1,
357  
-     bits32 b2,
358  
-     bits32 *z0Ptr,
359  
-     bits32 *z1Ptr,
360  
-     bits32 *z2Ptr
361  
- )
362  
-{
363  
-    bits32 z0, z1, z2;
364  
-    int8 borrow0, borrow1;
365  
-
366  
-    z2 = a2 - b2;
367  
-    borrow1 = ( a2 < b2 );
368  
-    z1 = a1 - b1;
369  
-    borrow0 = ( a1 < b1 );
370  
-    z0 = a0 - b0;
371  
-    z0 -= ( z1 < borrow1 );
372  
-    z1 -= borrow1;
373  
-    z0 -= borrow0;
374  
-    *z2Ptr = z2;
375  
-    *z1Ptr = z1;
376  
-    *z0Ptr = z0;
377  
-
378  
-}
379  
-
380  
-/*
381  
--------------------------------------------------------------------------------
382  
-Multiplies `a' by `b' to obtain a 64-bit product.  The product is broken
383  
-into two 32-bit pieces which are stored at the locations pointed to by
384  
-`z0Ptr' and `z1Ptr'.
385  
--------------------------------------------------------------------------------
386  
-*/
387  
-INLINE void mul32To64( bits32 a, bits32 b, bits32 *z0Ptr, bits32 *z1Ptr )
388  
-{
389  
-    bits16 aHigh, aLow, bHigh, bLow;
390  
-    bits32 z0, zMiddleA, zMiddleB, z1;
391  
-
392  
-    aLow = a;
393  
-    aHigh = a>>16;
394  
-    bLow = b;
395  
-    bHigh = b>>16;
396  
-    z1 = ( (bits32) aLow ) * bLow;
397  
-    zMiddleA = ( (bits32) aLow ) * bHigh;
398  
-    zMiddleB = ( (bits32) aHigh ) * bLow;
399  
-    z0 = ( (bits32) aHigh ) * bHigh;
400  
-    zMiddleA += zMiddleB;
401  
-    z0 += ( ( (bits32) ( zMiddleA < zMiddleB ) )<<16 ) + ( zMiddleA>>16 );
402  
-    zMiddleA <<= 16;
403  
-    z1 += zMiddleA;
404  
-    z0 += ( z1 < zMiddleA );
405  
-    *z1Ptr = z1;
406  
-    *z0Ptr = z0;
407  
-
408  
-}
409  
-
410  
-/*
411  
--------------------------------------------------------------------------------
412  
-Multiplies the 64-bit value formed by concatenating `a0' and `a1' by `b' to
413  
-obtain a 96-bit product.  The product is broken into three 32-bit pieces
414  
-which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and
415  
-`z2Ptr'.
416  
--------------------------------------------------------------------------------
417  
-*/
418  
-INLINE void
419  
- mul64By32To96(
420  
-     bits32 a0,
421  
-     bits32 a1,
422  
-     bits32 b,
423  
-     bits32 *z0Ptr,
424  
-     bits32 *z1Ptr,
425  
-     bits32 *z2Ptr
426  
- )
427  
-{
428  
-    bits32 z0, z1, z2, more1;
429  
-
430  
-    mul32To64( a1, b, &z1, &z2 );
431  
-    mul32To64( a0, b, &z0, &more1 );
432  
-    add64( z0, more1, 0, z1, &z0, &z1 );
433  
-    *z2Ptr = z2;
434  
-    *z1Ptr = z1;
435  
-    *z0Ptr = z0;
436  
-
437  
-}
438  
-
439  
-/*
440  
--------------------------------------------------------------------------------
441  
-Multiplies the 64-bit value formed by concatenating `a0' and `a1' to the
442  
-64-bit value formed by concatenating `b0' and `b1' to obtain a 128-bit
443  
-product.  The product is broken into four 32-bit pieces which are stored at
444  
-the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
445  
--------------------------------------------------------------------------------
446  
-*/
447  
-INLINE void
448  
- mul64To128(
449  
-     bits32 a0,
450  
-     bits32 a1,
451  
-     bits32 b0,
452  
-     bits32 b1,
453  
-     bits32 *z0Ptr,
454  
-     bits32 *z1Ptr,
455  
-     bits32 *z2Ptr,
456  
-     bits32 *z3Ptr
457  
- )
458  
-{
459  
-    bits32 z0, z1, z2, z3;
460  
-    bits32 more1, more2;
461  
-
462  
-    mul32To64( a1, b1, &z2, &z3 );
463  
-    mul32To64( a1, b0, &z1, &more2 );
464  
-    add64( z1, more2, 0, z2, &z1, &z2 );
465  
-    mul32To64( a0, b0, &z0, &more1 );
466  
-    add64( z0, more1, 0, z1, &z0, &z1 );
467  
-    mul32To64( a0, b1, &more1, &more2 );
468  
-    add64( more1, more2, 0, z2, &more1, &z2 );
469  
-    add64( z0, z1, 0, more1, &z0, &z1 );
470  
-    *z3Ptr = z3;
471  
-    *z2Ptr = z2;
472  
-    *z1Ptr = z1;
473  
-    *z0Ptr = z0;
474  
-
475  
-}
476  
-
477  
-/*
478  
--------------------------------------------------------------------------------
479  
-Returns an approximation to the 32-bit integer quotient obtained by dividing
480  
-`b' into the 64-bit value formed by concatenating `a0' and `a1'.  The divisor
481  
-`b' must be at least 2^31.  If q is the exact quotient truncated toward
482  
-zero, the approximation returned lies between q and q + 2 inclusive.  If
483  
-the exact quotient q is larger than 32 bits, the maximum positive 32-bit
484  
-unsigned integer is returned.
485  
--------------------------------------------------------------------------------
486  
-*/
487  
-static bits32 estimateDiv64To32( bits32 a0, bits32 a1, bits32 b )
488  
-{
489  
-    bits32 b0, b1;
490  
-    bits32 rem0, rem1, term0, term1;
491  
-    bits32 z;
492  
-
493  
-    if ( b <= a0 ) return 0xFFFFFFFF;
494  
-    b0 = b>>16;
495  
-    z = ( b0<<16 <= a0 ) ? 0xFFFF0000 : ( a0 / b0 )<<16;
496  
-    mul32To64( b, z, &term0, &term1 );
497  
-    sub64( a0, a1, term0, term1, &rem0, &rem1 );
498  
-    while ( ( (sbits32) rem0 ) < 0 ) {
499  
-        z -= 0x10000;
500  
-        b1 = b<<16;
501  
-        add64( rem0, rem1, b0, b1, &rem0, &rem1 );
502  
-    }
503  
-    rem0 = ( rem0<<16 ) | ( rem1>>16 );
504  
-    z |= ( b0<<16 <= rem0 ) ? 0xFFFF : rem0 / b0;
505  
-    return z;
506  
-
507  
-}
508  
-
509  
-/*
510  
--------------------------------------------------------------------------------
511  
-Returns an approximation to the square root of the 32-bit significand given
512  
-by `a'.  Considered as an integer, `a' must be at least 2^31.  If bit 0 of
513  
-`aExp' (the least significant bit) is 1, the integer returned approximates
514  
-2^31*sqrt(`a'/2^31), where `a' is considered an integer.  If bit 0 of `aExp'
515  
-is 0, the integer returned approximates 2^31*sqrt(`a'/2^30).  In either
516  
-case, the approximation returned lies strictly within +/-2 of the exact
517  
-value.
518  
--------------------------------------------------------------------------------
519  
-*/
520  
-static bits32 estimateSqrt32( int16 aExp, bits32 a )
521  
-{
522  
-    static const bits16 sqrtOddAdjustments[] = {
523  
-        0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
524  
-        0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
525  
-    };
526  
-    static const bits16 sqrtEvenAdjustments[] = {
527  
-        0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
528  
-        0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
529  
-    };
530  
-    int8 index;
531  
-    bits32 z;
532  
-
533  
-    index = ( a>>27 ) & 15;
534  
-    if ( aExp & 1 ) {
535  
-        z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ];
536  
-        z = ( ( a / z )<<14 ) + ( z<<15 );
537  
-        a >>= 1;
538  
-    }
539  
-    else {
540  
-        z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ];
541  
-        z = a / z + z;
542  
-        z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );
543  
-        if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 );
544  
-    }
545  
-    return ( ( estimateDiv64To32( a, 0, z ) )>>1 ) + ( z>>1 );
546  
-
547  
-}
548  
-
549  
-/*
550  
--------------------------------------------------------------------------------
551  
-Returns the number of leading 0 bits before the most-significant 1 bit
552  
-of `a'.  If `a' is zero, 32 is returned.
553  
--------------------------------------------------------------------------------
554  
-*/
555  
-static int8 countLeadingZeros32( bits32 a )
556  
-{
557  
-    static const int8 countLeadingZerosHigh[] = {
558  
-        8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
559  
-        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
560  
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
561  
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
562  
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
563  
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
564  
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
565  
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
566  
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
567  
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
568  
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
569  
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
570  
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
571  
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
572  
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
573  
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
574  
-    };
575  
-    int8 shiftCount;
576  
-
577  
-    shiftCount = 0;
578  
-    if ( a < 0x10000 ) {
579  
-        shiftCount += 16;
580  
-        a <<= 16;
581  
-    }
582  
-    if ( a < 0x1000000 ) {
583  
-        shiftCount += 8;
584  
-        a <<= 8;
585  
-    }
586  
-    shiftCount += countLeadingZerosHigh[ a>>24 ];
587  
-    return shiftCount;
588  
-
589  
-}
590  
-
591  
-/*
592  
--------------------------------------------------------------------------------
593  
-Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is equal
594  
-to the 64-bit value formed by concatenating `b0' and `b1'.  Otherwise,
595  
-returns 0.
596  
--------------------------------------------------------------------------------
597  
-*/
598  
-INLINE flag eq64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
599  
-{
600  
-
601  
-    return ( a0 == b0 ) && ( a1 == b1 );
602  
-
603  
-}
604  
-
605  
-/*
606  
--------------------------------------------------------------------------------
607  
-Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is less
608  
-than or equal to the 64-bit value formed by concatenating `b0' and `b1'.
609  
-Otherwise, returns 0.
610  
--------------------------------------------------------------------------------
611  
-*/
612  
-INLINE flag le64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
613  
-{
614  
-
615  
-    return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );
616  
-
617  
-}
618  
-
619  
-/*
620  
--------------------------------------------------------------------------------
621  
-Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is less
622  
-than the 64-bit value formed by concatenating `b0' and `b1'.  Otherwise,
623  
-returns 0.
624  
--------------------------------------------------------------------------------
625  
-*/
626  
-INLINE flag lt64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
627  
-{
628  
-
629  
-    return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
630  
-
631  
-}
632  
-
633  
-/*
634  
--------------------------------------------------------------------------------
635  
-Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is not
636  
-equal to the 64-bit value formed by concatenating `b0' and `b1'.  Otherwise,
637  
-returns 0.
638  
--------------------------------------------------------------------------------
639  
-*/
640  
-INLINE flag ne64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
641  
-{
642  
-
643  
-    return ( a0 != b0 ) || ( a1 != b1 );
644  
-
645  
-}
646  
-
  1
+
  2
+/*============================================================================
  3
+
  4
+This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
  5
+Arithmetic Package, Release 2b.
  6
+
  7
+Written by John R. Hauser.  This work was made possible in part by the
  8
+International Computer Science Institute, located at Suite 600, 1947 Center
  9
+Street, Berkeley, California 94704.  Funding was partially provided by the
  10
+National Science Foundation under grant MIP-9311980.  The original version
  11
+of this code was written as part of a project to build a fixed-point vector
  12
+processor in collaboration with the University of California at Berkeley,
  13
+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
  14
+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
  15
+arithmetic/SoftFloat.html'.
  16
+
  17
+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
  18
+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
  19
+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
  20
+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
  21
+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
  22
+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
  23
+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
  24
+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
  25
+
  26
+Derivative works are acceptable, even for commercial purposes, so long as
  27
+(1) the source code for the derivative work includes prominent notice that
  28
+the work is derivative, and (2) the source code includes prominent notice with
  29
+these four paragraphs for those parts of this code that are retained.
  30
+
  31
+=============================================================================*/
  32
+
  33
+/*----------------------------------------------------------------------------
  34
+| Shifts `a' right by the number of bits given in `count'.  If any nonzero
  35
+| bits are shifted off, they are ``jammed'' into the least significant bit of
  36
+| the result by setting the least significant bit to 1.  The value of `count'
  37
+| can be arbitrarily large; in particular, if `count' is greater than 32, the
  38
+| result will be either 0 or 1, depending on whether `a' is zero or nonzero.
  39
+| The result is stored in the location pointed to by `zPtr'.
  40
+*----------------------------------------------------------------------------*/
  41
+
  42
+INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr )
  43
+{
  44
+    bits32 z;
  45
+
  46
+    if ( count == 0 ) {
  47
+        z = a;
  48
+    }
  49
+    else if ( count < 32 ) {
  50
+        z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );
  51
+    }
  52
+    else {
  53
+        z = ( a != 0 );
  54
+    }
  55
+    *zPtr = z;
  56
+
  57
+}
  58
+
  59
+/*----------------------------------------------------------------------------
  60
+| Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the
  61
+| number of bits given in `count'.  Any bits shifted off are lost.  The value
  62
+| of `count' can be arbitrarily large; in particular, if `count' is greater
  63
+| than 64, the result will be 0.  The result is broken into two 32-bit pieces
  64
+| which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
  65
+*----------------------------------------------------------------------------*/
  66
+
  67
+INLINE void
  68
+ shift64Right(
  69
+     bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr )
  70
+{
  71
+    bits32 z0, z1;
  72
+    int8 negCount = ( - count ) & 31;
  73
+
  74
+    if ( count == 0 ) {
  75
+        z1 = a1;
  76
+        z0 = a0;
  77
+    }
  78
+    else if ( count < 32 ) {
  79
+        z1 = ( a0<<negCount ) | ( a1>>count );
  80
+        z0 = a0>>count;
  81
+    }
  82
+    else {
  83
+        z1 = ( count < 64 ) ? ( a0>>( count & 31 ) ) : 0;
  84
+        z0 = 0;
  85
+    }
  86
+    *z1Ptr = z1;
  87
+    *z0Ptr = z0;
  88
+
  89
+}
  90
+
  91
+/*----------------------------------------------------------------------------
  92
+| Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the
  93
+| number of bits given in `count'.  If any nonzero bits are shifted off, they
  94
+| are ``jammed'' into the least significant bit of the result by setting the
  95
+| least significant bit to 1.  The value of `count' can be arbitrarily large;
  96
+| in particular, if `count' is greater than 64, the result will be either 0
  97
+| or 1, depending on whether the concatenation of `a0' and `a1' is zero or
  98
+| nonzero.  The result is broken into two 32-bit pieces which are stored at
  99
+| the locations pointed to by `z0Ptr' and `z1Ptr'.
  100
+*----------------------------------------------------------------------------*/
  101
+
  102
+INLINE void
  103
+ shift64RightJamming(
  104
+     bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr )
  105
+{
  106
+    bits32 z0, z1;
  107
+    int8 negCount = ( - count ) & 31;
  108
+
  109
+    if ( count == 0 ) {
  110
+        z1 = a1;
  111
+        z0 = a0;
  112
+    }
  113
+    else if ( count < 32 ) {
  114
+        z1 = ( a0<<negCount ) | ( a1>>count ) | ( ( a1<<negCount ) != 0 );
  115
+        z0 = a0>>count;
  116
+    }
  117
+    else {
  118
+        if ( count == 32 ) {
  119
+            z1 = a0 | ( a1 != 0 );
  120
+        }
  121
+        else if ( count < 64 ) {
  122
+            z1 = ( a0>>( count & 31 ) ) | ( ( ( a0<<negCount ) | a1 ) != 0 );
  123
+        }
  124
+        else {
  125
+            z1 = ( ( a0 | a1 ) != 0 );
  126
+        }
  127
+        z0 = 0;
  128
+    }
  129
+    *z1Ptr = z1;
  130
+    *z0Ptr = z0;
  131
+
  132
+}
  133
+
  134
+/*----------------------------------------------------------------------------
  135
+| Shifts the 96-bit value formed by concatenating `a0', `a1', and `a2' right
  136
+| by 32 _plus_ the number of bits given in `count'.  The shifted result is
  137
+| at most 64 nonzero bits; these are broken into two 32-bit pieces which are
  138
+| stored at the locations pointed to by `z0Ptr' and `z1Ptr'.  The bits shifted
  139
+| off form a third 32-bit result as follows:  The _last_ bit shifted off is
  140
+| the most-significant bit of the extra result, and the other 31 bits of the
  141
+| extra result are all zero if and only if _all_but_the_last_ bits shifted off
  142
+| were all zero.  This extra result is stored in the location pointed to by
  143
+| `z2Ptr'.  The value of `count' can be arbitrarily large.
  144
+|     (This routine makes more sense if `a0', `a1', and `a2' are considered
  145
+| to form a fixed-point value with binary point between `a1' and `a2'.  This
  146
+| fixed-point value is shifted right by the number of bits given in `count',
  147
+| and the integer part of the result is returned at the locations pointed to
  148
+| by `z0Ptr' and `z1Ptr'.  The fractional part of the result may be slightly
  149
+| corrupted as described above, and is returned at the location pointed to by
  150
+| `z2Ptr'.)
  151
+*----------------------------------------------------------------------------*/
  152
+
  153
+INLINE void
  154
+ shift64ExtraRightJamming(
  155
+     bits32 a0,
  156
+     bits32 a1,
  157
+     bits32 a2,
  158
+     int16 count,
  159
+     bits32 *z0Ptr,
  160
+     bits32 *z1Ptr,
  161
+     bits32 *z2Ptr
  162
+ )
  163
+{
  164
+    bits32 z0, z1, z2;
  165
+    int8 negCount = ( - count ) & 31;
  166
+
  167
+    if ( count == 0 ) {
  168
+        z2 = a2;
  169
+        z1 = a1;
  170
+        z0 = a0;
  171
+    }
  172
+    else {
  173
+        if ( count < 32 ) {
  174
+            z2 = a1<<negCount;
  175
+            z1 = ( a0<<negCount ) | ( a1>>count );
  176
+            z0 = a0>>count;
  177
+        }
  178
+        else {
  179
+            if ( count == 32 ) {
  180
+                z2 = a1;
  181
+                z1 = a0;
  182
+            }
  183
+            else {
  184
+                a2 |= a1;
  185
+                if ( count < 64 ) {
  186
+                    z2 = a0<<negCount;
  187
+                    z1 = a0>>( count & 31 );
  188
+                }
  189
+                else {
  190
+                    z2 = ( count == 64 ) ? a0 : ( a0 != 0 );
  191
+                    z1 = 0;
  192
+                }
  193
+            }
  194
+            z0 = 0;
  195
+        }
  196
+        z2 |= ( a2 != 0 );
  197
+    }
  198
+    *z2Ptr = z2;
  199
+    *z1Ptr = z1;
  200
+    *z0Ptr = z0;
  201
+
  202
+}
  203
+
  204
+/*----------------------------------------------------------------------------
  205
+| Shifts the 64-bit value formed by concatenating `a0' and `a1' left by the
  206
+| number of bits given in `count'.  Any bits shifted off are lost.  The value
  207
+| of `count' must be less than 32.  The result is broken into two 32-bit
  208
+| pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
  209
+*----------------------------------------------------------------------------*/
  210
+
  211
+INLINE void
  212
+ shortShift64Left(
  213
+     bits32 a0, bits32 a1, int16 count, bits32 *z0Ptr, bits32 *z1Ptr )
  214
+{
  215
+
  216
+    *z1Ptr = a1<<count;
  217
+    *z0Ptr =
  218
+        ( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 31 ) );
  219
+
  220
+}
  221
+
  222
+/*----------------------------------------------------------------------------
  223
+| Shifts the 96-bit value formed by concatenating `a0', `a1', and `a2' left
  224
+| by the number of bits given in `count'.  Any bits shifted off are lost.
  225
+| The value of `count' must be less than 32.  The result is broken into three
  226
+| 32-bit pieces which are stored at the locations pointed to by `z0Ptr',
  227
+| `z1Ptr', and `z2Ptr'.
  228
+*----------------------------------------------------------------------------*/
  229
+
  230
+INLINE void
  231
+ shortShift96Left(
  232
+     bits32 a0,
  233
+     bits32 a1,
  234
+     bits32 a2,
  235
+     int16 count,
  236
+     bits32 *z0Ptr,
  237
+     bits32 *z1Ptr,
  238
+     bits32 *z2Ptr
  239
+ )
  240
+{
  241
+    bits32 z0, z1, z2;
  242
+    int8 negCount;
  243
+
  244
+    z2 = a2<<count;
  245
+    z1 = a1<<count;
  246
+    z0 = a0<<count;
  247
+    if ( 0 < count ) {
  248
+        negCount = ( ( - count ) & 31 );
  249
+        z1 |= a2>>negCount;
  250
+        z0 |= a1>>negCount;
  251
+    }
  252
+    *z2Ptr = z2;
  253
+    *z1Ptr = z1;
  254
+    *z0Ptr = z0;
  255
+
  256
+}
  257
+
  258
+/*----------------------------------------------------------------------------
  259
+| Adds the 64-bit value formed by concatenating `a0' and `a1' to the 64-bit
  260
+| value formed by concatenating `b0' and `b1'.  Addition is modulo 2^64, so
  261
+| any carry out is lost.  The result is broken into two 32-bit pieces which
  262
+| are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
  263
+*----------------------------------------------------------------------------*/
  264
+
  265
+INLINE void
  266
+ add64(
  267
+     bits32 a0, bits32 a1, bits32 b0, bits32 b1, bits32 *z0Ptr, bits32 *z1Ptr )
  268
+{
  269
+    bits32 z1;
  270
+
  271
+    z1 = a1 + b1;
  272
+    *z1Ptr = z1;
  273
+    *z0Ptr = a0 + b0 + ( z1 < a1 );
  274
+
  275
+}
  276
+
  277
+/*----------------------------------------------------------------------------
  278
+| Adds the 96-bit value formed by concatenating `a0', `a1', and `a2' to the
  279
+| 96-bit value formed by concatenating `b0', `b1', and `b2'.  Addition is
  280
+| modulo 2^96, so any carry out is lost.  The result is broken into three
  281
+| 32-bit pieces which are stored at the locations pointed to by `z0Ptr',
  282
+| `z1Ptr', and `z2Ptr'.
  283
+*----------------------------------------------------------------------------*/
  284
+
  285
+INLINE void
  286
+ add96(
  287
+     bits32 a0,
  288
+     bits32 a1,
  289
+     bits32 a2,
  290
+     bits32 b0,
  291
+     bits32 b1,
  292
+     bits32 b2,
  293
+     bits32 *z0Ptr,
  294
+     bits32 *z1Ptr,
  295
+     bits32 *z2Ptr
  296
+ )
  297
+{
  298
+    bits32 z0, z1, z2;
  299
+    int8 carry0, carry1;
  300
+
  301
+    z2 = a2 + b2;
  302
+    carry1 = ( z2 < a2 );
  303
+    z1 = a1 + b1;
  304
+    carry0 = ( z1 < a1 );
  305
+    z0 = a0 + b0;
  306
+    z1 += carry1;
  307
+    z0 += ( z1 < carry1 );
  308
+    z0 += carry0;
  309
+    *z2Ptr = z2;
  310
+    *z1Ptr = z1;
  311
+    *z0Ptr = z0;
  312
+
  313
+}
  314
+
  315
+/*----------------------------------------------------------------------------
  316
+| Subtracts the 64-bit value formed by concatenating `b0' and `b1' from the
  317
+| 64-bit value formed by concatenating `a0' and `a1'.  Subtraction is modulo
  318
+| 2^64, so any borrow out (carry out) is lost.  The result is broken into two
  319
+| 32-bit pieces which are stored at the locations pointed to by `z0Ptr' and
  320
+| `z1Ptr'.
  321
+*----------------------------------------------------------------------------*/
  322
+
  323
+INLINE void
  324
+ sub64(
  325
+     bits32 a0, bits32 a1, bits32 b0, bits32 b1, bits32 *z0Ptr, bits32 *z1Ptr )
  326
+{
  327
+
  328
+    *z1Ptr = a1 - b1;
  329
+    *z0Ptr = a0 - b0 - ( a1 < b1 );
  330
+
  331
+}
  332
+
  333
+/*----------------------------------------------------------------------------
  334
+| Subtracts the 96-bit value formed by concatenating `b0', `b1', and `b2' from
  335
+| the 96-bit value formed by concatenating `a0', `a1', and `a2'.  Subtraction
  336
+| is modulo 2^96, so any borrow out (carry out) is lost.  The result is broken
  337
+| into three 32-bit pieces which are stored at the locations pointed to by
  338
+| `z0Ptr', `z1Ptr', and `z2Ptr'.
  339
+*----------------------------------------------------------------------------*/
  340
+
  341
+INLINE void
  342
+ sub96(
  343
+     bits32 a0,
  344
+     bits32 a1,
  345
+     bits32 a2,
  346
+     bits32 b0,
  347
+     bits32 b1,
  348
+     bits32 b2,
  349
+     bits32 *z0Ptr,
  350
+     bits32 *z1Ptr,
  351
+     bits32 *z2Ptr
  352
+ )
  353
+{
  354
+    bits32 z0, z1, z2;
  355
+    int8 borrow0, borrow1;
  356
+
  357
+    z2 = a2 - b2;
  358
+    borrow1 = ( a2 < b2 );
  359
+    z1 = a1 - b1;
  360
+    borrow0 = ( a1 < b1 );
  361
+    z0 = a0 - b0;
  362
+    z0 -= ( z1 < borrow1 );
  363
+    z1 -= borrow1;
  364
+    z0 -= borrow0;
  365
+    *z2Ptr = z2;
  366
+    *z1Ptr = z1;
  367
+    *z0Ptr = z0;
  368
+
  369
+}
  370
+
  371
+/*----------------------------------------------------------------------------
  372
+| Multiplies `a' by `b' to obtain a 64-bit product.  The product is broken
  373
+| into two 32-bit pieces which are stored at the locations pointed to by
  374
+| `z0Ptr' and `z1Ptr'.
  375
+*----------------------------------------------------------------------------*/
  376
+
  377
+INLINE void mul32To64( bits32 a, bits32 b, bits32 *z0Ptr, bits32 *z1Ptr )
  378
+{
  379
+    bits16 aHigh, aLow, bHigh, bLow;
  380
+    bits32 z0, zMiddleA, zMiddleB, z1;
  381
+
  382
+    aLow = a;
  383
+    aHigh = a>>16;
  384
+    bLow = b;
  385
+    bHigh = b>>16;
  386
+    z1 = ( (bits32) aLow ) * bLow;
  387
+    zMiddleA = ( (bits32) aLow ) * bHigh;
  388
+    zMiddleB = ( (bits32) aHigh ) * bLow;
  389
+    z0 = ( (bits32) aHigh ) * bHigh;
  390
+    zMiddleA += zMiddleB;
  391
+    z0 += ( ( (bits32) ( zMiddleA < zMiddleB ) )<<16 ) + ( zMiddleA>>16 );
  392
+    zMiddleA <<= 16;
  393
+    z1 += zMiddleA;
  394
+    z0 += ( z1 < zMiddleA );
  395
+    *z1Ptr = z1;
  396
+    *z0Ptr = z0;
  397
+
  398
+}
  399
+
  400
+/*----------------------------------------------------------------------------
  401
+| Multiplies the 64-bit value formed by concatenating `a0' and `a1' by `b'
  402
+| to obtain a 96-bit product.  The product is broken into three 32-bit pieces
  403
+| which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and
  404
+| `z2Ptr'.
  405
+*----------------------------------------------------------------------------*/
  406
+
  407
+INLINE void
  408
+ mul64By32To96(
  409
+     bits32 a0,
  410
+     bits32 a1,
  411
+     bits32 b,
  412
+     bits32 *z0Ptr,
  413
+     bits32 *z1Ptr,
  414
+     bits32 *z2Ptr
  415
+ )
  416
+{
  417
+    bits32 z0, z1, z2, more1;
  418
+
  419
+    mul32To64( a1, b, &z1, &z2 );
  420
+    mul32To64( a0, b, &z0, &more1 );
  421
+    add64( z0, more1, 0, z1, &z0, &z1 );
  422
+    *z2Ptr = z2;
  423
+    *z1Ptr = z1;
  424
+    *z0Ptr = z0;
  425
+
  426
+}
  427
+
  428
+/*----------------------------------------------------------------------------
  429
+| Multiplies the 64-bit value formed by concatenating `a0' and `a1' to the
  430
+| 64-bit value formed by concatenating `b0' and `b1' to obtain a 128-bit
  431
+| product.  The product is broken into four 32-bit pieces which are stored at
  432
+| the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
  433
+*----------------------------------------------------------------------------*/
  434
+
  435
+INLINE void
  436
+ mul64To128(
  437
+     bits32 a0,
  438
+     bits32 a1,
  439
+     bits32 b0,
  440
+     bits32 b1,
  441
+     bits32 *z0Ptr,
  442
+     bits32 *z1Ptr,
  443
+     bits32 *z2Ptr,
  444
+     bits32 *z3Ptr
  445
+ )
  446
+{
  447
+    bits32 z0, z1, z2, z3;
  448
+    bits32 more1, more2;
  449
+
  450
+    mul32To64( a1, b1, &z2, &z3 );
  451
+    mul32To64( a1, b0, &z1, &more2 );
  452
+    add64( z1, more2, 0, z2, &z1, &z2 );
  453
+    mul32To64( a0, b0, &z0, &more1 );
  454
+    add64( z0, more1, 0, z1, &z0, &z1 );
  455
+    mul32To64( a0, b1, &more1, &more2 );
  456
+    add64( more1, more2, 0, z2, &more1, &z2 );
  457
+    add64( z0, z1, 0, more1, &z0, &z1 );
  458
+    *z3Ptr = z3;
  459
+    *z2Ptr = z2;
  460
+    *z1Ptr = z1;
  461
+    *z0Ptr = z0;
  462
+
  463
+}
  464
+
  465
+/*----------------------------------------------------------------------------
  466
+| Returns an approximation to the 32-bit integer quotient obtained by dividing
  467
+| `b' into the 64-bit value formed by concatenating `a0' and `a1'.  The
  468
+| divisor `b' must be at least 2^31.  If q is the exact quotient truncated
  469
+| toward zero, the approximation returned lies between q and q + 2 inclusive.
  470
+| If the exact quotient q is larger than 32 bits, the maximum positive 32-bit
  471
+| unsigned integer is returned.
  472
+*----------------------------------------------------------------------------*/
  473
+
  474
+static bits32 estimateDiv64To32( bits32 a0, bits32 a1, bits32 b )
  475
+{
  476
+    bits32 b0, b1;
  477
+    bits32 rem0, rem1, term0, term1;
  478
+    bits32 z;
  479
+
  480
+    if ( b <= a0 ) return 0xFFFFFFFF;
  481
+    b0 = b>>16;
  482
+    z = ( b0<<16 <= a0 ) ? 0xFFFF0000 : ( a0 / b0 )<<16;
  483
+    mul32To64( b, z, &term0, &term1 );
  484
+    sub64( a0, a1, term0, term1, &rem0, &rem1 );
  485
+    while ( ( (sbits32) rem0 ) < 0 ) {
  486
+        z -= 0x10000;
  487
+        b1 = b<<16;
  488
+        add64( rem0, rem1, b0, b1, &rem0, &rem1 );
  489
+    }
  490
+    rem0 = ( rem0<<16 ) | ( rem1>>16 );
  491
+    z |= ( b0<<16 <= rem0 ) ? 0xFFFF : rem0 / b0;
  492
+    return z;
  493
+
  494
+}
  495
+
  496
+/*----------------------------------------------------------------------------
  497
+| Returns an approximation to the square root of the 32-bit significand given
  498
+| by `a'.  Considered as an integer, `a' must be at least 2^31.  If bit 0 of
  499
+| `aExp' (the least significant bit) is 1, the integer returned approximates
  500
+| 2^31*sqrt(`a'/2^31), where `a' is considered an integer.  If bit 0 of `aExp'
  501
+| is 0, the integer returned approximates 2^31*sqrt(`a'/2^30).  In either
  502
+| case, the approximation returned lies strictly within +/-2 of the exact
  503
+| value.
  504
+*----------------------------------------------------------------------------*/
  505
+
  506
+static bits32 estimateSqrt32( int16 aExp, bits32 a )
  507
+{
  508
+    static const bits16 sqrtOddAdjustments[] = {
  509
+        0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,
  510
+        0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67
  511
+    };
  512
+    static const bits16 sqrtEvenAdjustments[] = {
  513
+        0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,
  514
+        0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002
  515
+    };
  516
+    int8 index;
  517
+    bits32 z;
  518
+
  519
+    index = ( a>>27 ) & 15;
  520
+    if ( aExp & 1 ) {
  521
+        z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ];
  522
+        z = ( ( a / z )<<14 ) + ( z<<15 );
  523
+        a >>= 1;
  524
+    }
  525
+    else {
  526
+        z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ];
  527
+        z = a / z + z;
  528
+        z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );
  529
+        if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 );
  530
+    }
  531
+    return ( ( estimateDiv64To32( a, 0, z ) )>>1 ) + ( z>>1 );
  532
+
  533
+}
  534
+
  535
+/*----------------------------------------------------------------------------
  536
+| Returns the number of leading 0 bits before the most-significant 1 bit of
  537
+| `a'.  If `a' is zero, 32 is returned.
  538
+*----------------------------------------------------------------------------*/
  539
+
  540
+static int8 countLeadingZeros32( bits32 a )
  541
+{
  542
+    static const int8 countLeadingZerosHigh[] = {
  543
+        8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
  544
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  545
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  546
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  547
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  548
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  549
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  550
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  551
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  552
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  553
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  554
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  555
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  556
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  557
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  558
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  559
+    };
  560
+    int8 shiftCount;
  561
+
  562
+    shiftCount = 0;
  563
+    if ( a < 0x10000 ) {
  564
+        shiftCount += 16;
  565
+        a <<= 16;
  566
+    }
  567
+    if ( a < 0x1000000 ) {
  568
+        shiftCount += 8;
  569
+        a <<= 8;
  570
+    }
  571
+    shiftCount += countLeadingZerosHigh[ a>>24 ];
  572
+    return shiftCount;
  573
+
  574
+}
  575
+
  576
+/*----------------------------------------------------------------------------
  577
+| Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is
  578
+| equal to the 64-bit value formed by concatenating `b0' and `b1'.  Otherwise,
  579
+| returns 0.
  580
+*----------------------------------------------------------------------------*/
  581
+
  582
+INLINE flag eq64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
  583
+{
  584
+
  585
+    return ( a0 == b0 ) && ( a1 == b1 );
  586
+
  587
+}
  588
+
  589
+/*----------------------------------------------------------------------------
  590
+| Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is less
  591
+| than or equal to the 64-bit value formed by concatenating `b0' and `b1'.
  592
+| Otherwise, returns 0.
  593
+*----------------------------------------------------------------------------*/
  594
+
  595
+INLINE flag le64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
  596
+{
  597
+
  598
+    return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );
  599
+
  600
+}
  601
+
  602
+/*----------------------------------------------------------------------------
  603
+| Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is less
  604
+| than the 64-bit value formed by concatenating `b0' and `b1'.  Otherwise,
  605
+| returns 0.
  606
+*----------------------------------------------------------------------------*/
  607
+
  608
+INLINE flag lt64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
  609
+{
  610
+
  611
+    return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
  612
+
  613
+}
  614
+
  615
+/*----------------------------------------------------------------------------
  616
+| Returns 1 if the 64-bit value formed by concatenating `a0' and `a1' is not
  617
+| equal to the 64-bit value formed by concatenating `b0' and `b1'.  Otherwise,
  618
+| returns 0.
  619
+*----------------------------------------------------------------------------*/
  620
+
  621
+INLINE flag ne64( bits32 a0, bits32 a1, bits32 b0, bits32 b1 )
  622
+{
  623
+
  624
+    return ( a0 != b0 ) || ( a1 != b1 );
  625
+
  626
+}
  627
+
239  software/libbase/softfloat-specialize.h
... ...
@@ -1,9 +1,8 @@
1 1
 
2  
-/*
3  
-===============================================================================
  2
+/*============================================================================
4 3
 
5 4
 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
6  
-Arithmetic Package, Release 2.
  5
+Arithmetic Package, Release 2b.
7 6
 
8 7
 Written by John R. Hauser.  This work was made possible in part by the
9 8
 International Computer Science Institute, located at Suite 600, 1947 Center
@@ -12,39 +11,38 @@ National Science Foundation under grant MIP-9311980.  The original version
12 11
 of this code was written as part of a project to build a fixed-point vector
13 12
 processor in collaboration with the University of California at Berkeley,
14 13
 overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
15  
-is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
16  
-arithmetic/softfloat.html'.
17  
-
18  
-THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
19  
-has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
20  
-TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
21  
-PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
22  
-AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
  14
+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
  15
+arithmetic/SoftFloat.html'.
  16
+
  17
+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
  18
+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
  19
+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
  20
+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
  21
+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
  22
+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
  23
+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
  24
+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
23 25
 
24 26
 Derivative works are acceptable, even for commercial purposes, so long as
25  
-(1) they include prominent notice that the work is derivative, and (2) they
26  
-include prominent notice akin to these three paragraphs for those parts of
27  
-this code that are retained.
28  
-
29  
-===============================================================================
30  
-*/
31  
-
32  
-/*
33  
--------------------------------------------------------------------------------
34  
-Underflow tininess-detection mode, statically initialized to default value.
35  
-(The declaration in `softfloat.h' must match the `int8' type here.)
36  
--------------------------------------------------------------------------------
37  
-*/
  27
+(1) the source code for the derivative work includes prominent notice that
  28
+the work is derivative, and (2) the source code includes prominent notice with
  29
+these four paragraphs for those parts of this code that are retained.
  30
+
  31
+=============================================================================*/
  32
+
  33
+/*----------------------------------------------------------------------------
  34
+| Underflow tininess-detection mode, statically initialized to default value.
  35
+| (The declaration in `softfloat.h' must match the `int8' type here.)
  36
+*----------------------------------------------------------------------------*/
38 37
 int8 float_detect_tininess = float_tininess_after_rounding;
39 38
 
40  
-/*
41  
--------------------------------------------------------------------------------
42  
-Raises the exceptions specified by `flags'.  Floating-point traps can be
43  
-defined here if desired.  It is currently not possible for such a trap to
44  
-substitute a result value.  If traps are not implemented, this routine
45  
-should be simply `float_exception_flags |= flags;'.
46  
--------------------------------------------------------------------------------
47  
-*/
  39
+/*----------------------------------------------------------------------------
  40
+| Raises the exceptions specified by `flags'.  Floating-point traps can be
  41
+| defined here if desired.  It is currently not possible for such a trap
  42
+| to substitute a result value.  If traps are not implemented, this routine
  43
+| should be simply `float_exception_flags |= flags;'.
  44
+*----------------------------------------------------------------------------*/
  45
+
48 46
 void float_raise( int8 flags )
49 47
 {
50 48
 
@@ -52,31 +50,26 @@ void float_raise( int8 flags )
52 50
 
53 51
 }
54 52
 
55  
-/*
56  
--------------------------------------------------------------------------------
57  
-Internal canonical NaN format.
58  
--------------------------------------------------------------------------------
59  
-*/
  53
+/*----------------------------------------------------------------------------
  54
+| Internal canonical NaN format.
  55
+*----------------------------------------------------------------------------*/
60 56
 typedef struct {
61 57
     flag sign;
62 58
     bits32 high, low;
63 59
 } commonNaNT;
64 60
 
65  
-/*
66  
--------------------------------------------------------------------------------
67  
-The pattern for a default generated single-precision NaN.
68  
--------------------------------------------------------------------------------
69  
-*/
  61
+/*----------------------------------------------------------------------------
  62
+| The pattern for a default generated single-precision NaN.
  63
+*----------------------------------------------------------------------------*/
70 64
 enum {
71 65
     float32_default_nan = 0xFFFFFFFF
72 66
 };