Finishes removal of x86_32 (XCC)
[akaros.git] / kern / arch / riscv / softfloat-macros.h
1 \r
2 /*============================================================================\r
3 \r
4 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point\r
5 Arithmetic Package, Release 2b.\r
6 \r
7 Written by John R. Hauser.  This work was made possible in part by the\r
8 International Computer Science Institute, located at Suite 600, 1947 Center\r
9 Street, Berkeley, California 94704.  Funding was partially provided by the\r
10 National Science Foundation under grant MIP-9311980.  The original version\r
11 of this code was written as part of a project to build a fixed-point vector\r
12 processor in collaboration with the University of California at Berkeley,\r
13 overseen by Profs. Nelson Morgan and John Wawrzynek.  More information\r
14 is available through the Web page `http://www.cs.berkeley.edu/~jhauser/\r
15 arithmetic/SoftFloat.html'.\r
16 \r
17 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has\r
18 been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES\r
19 RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS\r
20 AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,\r
21 COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE\r
22 EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE\r
23 INSTITUTE (possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR\r
24 OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.\r
25 \r
26 Derivative works are acceptable, even for commercial purposes, so long as\r
27 (1) the source code for the derivative work includes prominent notice that\r
28 the work is derivative, and (2) the source code includes prominent notice with\r
29 these four paragraphs for those parts of this code that are retained.\r
30 \r
31 =============================================================================*/\r
32 \r
33 /*----------------------------------------------------------------------------\r
34 | Shifts `a' right by the number of bits given in `count'.  If any nonzero\r
35 | bits are shifted off, they are ``jammed'' into the least significant bit of\r
36 | the result by setting the least significant bit to 1.  The value of `count'\r
37 | can be arbitrarily large; in particular, if `count' is greater than 32, the\r
38 | result will be either 0 or 1, depending on whether `a' is zero or nonzero.\r
39 | The result is stored in the location pointed to by `zPtr'.\r
40 *----------------------------------------------------------------------------*/\r
41 \r
42 INLINE void shift32RightJamming( bits32 a, int16_t count, bits32 *zPtr )\r
43 {\r
44     bits32 z;\r
45 \r
46     if ( count == 0 ) {\r
47         z = a;\r
48     }\r
49     else if ( count < 32 ) {\r
50         z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );\r
51     }\r
52     else {\r
53         z = ( a != 0 );\r
54     }\r
55     *zPtr = z;\r
56 \r
57 }\r
58 \r
59 /*----------------------------------------------------------------------------\r
60 | Shifts `a' right by the number of bits given in `count'.  If any nonzero\r
61 | bits are shifted off, they are ``jammed'' into the least significant bit of\r
62 | the result by setting the least significant bit to 1.  The value of `count'\r
63 | can be arbitrarily large; in particular, if `count' is greater than 64, the\r
64 | result will be either 0 or 1, depending on whether `a' is zero or nonzero.\r
65 | The result is stored in the location pointed to by `zPtr'.\r
66 *----------------------------------------------------------------------------*/\r
67 \r
68 INLINE void shift64RightJamming( bits64 a, int16_t count, bits64 *zPtr )\r
69 {\r
70     bits64 z;\r
71 \r
72     if ( count == 0 ) {\r
73         z = a;\r
74     }\r
75     else if ( count < 64 ) {\r
76         z = ( a>>count ) | ( ( a<<( ( - count ) & 63 ) ) != 0 );\r
77     }\r
78     else {\r
79         z = ( a != 0 );\r
80     }\r
81     *zPtr = z;\r
82 \r
83 }\r
84 \r
85 /*----------------------------------------------------------------------------\r
86 | Shifts the 128-bit value formed by concatenating `a0' and `a1' right by 64\r
87 | _plus_ the number of bits given in `count'.  The shifted result is at most\r
88 | 64 nonzero bits; this is stored at the location pointed to by `z0Ptr'.  The\r
89 | bits shifted off form a second 64-bit result as follows:  The _last_ bit\r
90 | shifted off is the most-significant bit of the extra result, and the other\r
91 | 63 bits of the extra result are all zero if and only if _all_but_the_last_\r
92 | bits shifted off were all zero.  This extra result is stored in the location\r
93 | pointed to by `z1Ptr'.  The value of `count' can be arbitrarily large.\r
94 |     (This routine makes more sense if `a0' and `a1' are considered to form\r
95 | a fixed-point value with binary point between `a0' and `a1'.  This fixed-\r
96 | point value is shifted right by the number of bits given in `count', and\r
97 | the integer part of the result is returned at the location pointed to by\r
98 | `z0Ptr'.  The fractional part of the result may be slightly corrupted as\r
99 | described above, and is returned at the location pointed to by `z1Ptr'.)\r
100 *----------------------------------------------------------------------------*/\r
101 \r
102 INLINE void\r
103  shift64ExtraRightJamming(\r
104      bits64 a0, bits64 a1, int16_t count, bits64 *z0Ptr, bits64 *z1Ptr )\r
105 {\r
106     bits64 z0, z1;\r
107     int8_t negCount = ( - count ) & 63;\r
108 \r
109     if ( count == 0 ) {\r
110         z1 = a1;\r
111         z0 = a0;\r
112     }\r
113     else if ( count < 64 ) {\r
114         z1 = ( a0<<negCount ) | ( a1 != 0 );\r
115         z0 = a0>>count;\r
116     }\r
117     else {\r
118         if ( count == 64 ) {\r
119             z1 = a0 | ( a1 != 0 );\r
120         }\r
121         else {\r
122             z1 = ( ( a0 | a1 ) != 0 );\r
123         }\r
124         z0 = 0;\r
125     }\r
126     *z1Ptr = z1;\r
127     *z0Ptr = z0;\r
128 \r
129 }\r
130 \r
131 /*----------------------------------------------------------------------------\r
132 | Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the\r
133 | number of bits given in `count'.  Any bits shifted off are lost.  The value\r
134 | of `count' can be arbitrarily large; in particular, if `count' is greater\r
135 | than 128, the result will be 0.  The result is broken into two 64-bit pieces\r
136 | which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.\r
137 *----------------------------------------------------------------------------*/\r
138 \r
139 INLINE void\r
140  shift128Right(\r
141      bits64 a0, bits64 a1, int16_t count, bits64 *z0Ptr, bits64 *z1Ptr )\r
142 {\r
143     bits64 z0, z1;\r
144     int8_t negCount = ( - count ) & 63;\r
145 \r
146     if ( count == 0 ) {\r
147         z1 = a1;\r
148         z0 = a0;\r
149     }\r
150     else if ( count < 64 ) {\r
151         z1 = ( a0<<negCount ) | ( a1>>count );\r
152         z0 = a0>>count;\r
153     }\r
154     else {\r
155         z1 = ( count < 64 ) ? ( a0>>( count & 63 ) ) : 0;\r
156         z0 = 0;\r
157     }\r
158     *z1Ptr = z1;\r
159     *z0Ptr = z0;\r
160 \r
161 }\r
162 \r
163 /*----------------------------------------------------------------------------\r
164 | Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the\r
165 | number of bits given in `count'.  If any nonzero bits are shifted off, they\r
166 | are ``jammed'' into the least significant bit of the result by setting the\r
167 | least significant bit to 1.  The value of `count' can be arbitrarily large;\r
168 | in particular, if `count' is greater than 128, the result will be either\r
169 | 0 or 1, depending on whether the concatenation of `a0' and `a1' is zero or\r
170 | nonzero.  The result is broken into two 64-bit pieces which are stored at\r
171 | the locations pointed to by `z0Ptr' and `z1Ptr'.\r
172 *----------------------------------------------------------------------------*/\r
173 \r
174 INLINE void\r
175  shift128RightJamming(\r
176      bits64 a0, bits64 a1, int16_t count, bits64 *z0Ptr, bits64 *z1Ptr )\r
177 {\r
178     bits64 z0, z1;\r
179     int8_t negCount = ( - count ) & 63;\r
180 \r
181     if ( count == 0 ) {\r
182         z1 = a1;\r
183         z0 = a0;\r
184     }\r
185     else if ( count < 64 ) {\r
186         z1 = ( a0<<negCount ) | ( a1>>count ) | ( ( a1<<negCount ) != 0 );\r
187         z0 = a0>>count;\r
188     }\r
189     else {\r
190         if ( count == 64 ) {\r
191             z1 = a0 | ( a1 != 0 );\r
192         }\r
193         else if ( count < 128 ) {\r
194             z1 = ( a0>>( count & 63 ) ) | ( ( ( a0<<negCount ) | a1 ) != 0 );\r
195         }\r
196         else {\r
197             z1 = ( ( a0 | a1 ) != 0 );\r
198         }\r
199         z0 = 0;\r
200     }\r
201     *z1Ptr = z1;\r
202     *z0Ptr = z0;\r
203 \r
204 }\r
205 \r
206 /*----------------------------------------------------------------------------\r
207 | Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' right\r
208 | by 64 _plus_ the number of bits given in `count'.  The shifted result is\r
209 | at most 128 nonzero bits; these are broken into two 64-bit pieces which are\r
210 | stored at the locations pointed to by `z0Ptr' and `z1Ptr'.  The bits shifted\r
211 | off form a third 64-bit result as follows:  The _last_ bit shifted off is\r
212 | the most-significant bit of the extra result, and the other 63 bits of the\r
213 | extra result are all zero if and only if _all_but_the_last_ bits shifted off\r
214 | were all zero.  This extra result is stored in the location pointed to by\r
215 | `z2Ptr'.  The value of `count' can be arbitrarily large.\r
216 |     (This routine makes more sense if `a0', `a1', and `a2' are considered\r
217 | to form a fixed-point value with binary point between `a1' and `a2'.  This\r
218 | fixed-point value is shifted right by the number of bits given in `count',\r
219 | and the integer part of the result is returned at the locations pointed to\r
220 | by `z0Ptr' and `z1Ptr'.  The fractional part of the result may be slightly\r
221 | corrupted as described above, and is returned at the location pointed to by\r
222 | `z2Ptr'.)\r
223 *----------------------------------------------------------------------------*/\r
224 \r
225 INLINE void\r
226  shift128ExtraRightJamming(\r
227      bits64 a0,\r
228      bits64 a1,\r
229      bits64 a2,\r
230      int16_t count,\r
231      bits64 *z0Ptr,\r
232      bits64 *z1Ptr,\r
233      bits64 *z2Ptr\r
234  )\r
235 {\r
236     bits64 z0, z1, z2;\r
237     int8_t negCount = ( - count ) & 63;\r
238 \r
239     if ( count == 0 ) {\r
240         z2 = a2;\r
241         z1 = a1;\r
242         z0 = a0;\r
243     }\r
244     else {\r
245         if ( count < 64 ) {\r
246             z2 = a1<<negCount;\r
247             z1 = ( a0<<negCount ) | ( a1>>count );\r
248             z0 = a0>>count;\r
249         }\r
250         else {\r
251             if ( count == 64 ) {\r
252                 z2 = a1;\r
253                 z1 = a0;\r
254             }\r
255             else {\r
256                 a2 |= a1;\r
257                 if ( count < 128 ) {\r
258                     z2 = a0<<negCount;\r
259                     z1 = a0>>( count & 63 );\r
260                 }\r
261                 else {\r
262                     z2 = ( count == 128 ) ? a0 : ( a0 != 0 );\r
263                     z1 = 0;\r
264                 }\r
265             }\r
266             z0 = 0;\r
267         }\r
268         z2 |= ( a2 != 0 );\r
269     }\r
270     *z2Ptr = z2;\r
271     *z1Ptr = z1;\r
272     *z0Ptr = z0;\r
273 \r
274 }\r
275 \r
276 /*----------------------------------------------------------------------------\r
277 | Shifts the 128-bit value formed by concatenating `a0' and `a1' left by the\r
278 | number of bits given in `count'.  Any bits shifted off are lost.  The value\r
279 | of `count' must be less than 64.  The result is broken into two 64-bit\r
280 | pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.\r
281 *----------------------------------------------------------------------------*/\r
282 \r
283 INLINE void\r
284  shortShift128Left(\r
285      bits64 a0, bits64 a1, int16_t count, bits64 *z0Ptr, bits64 *z1Ptr )\r
286 {\r
287 \r
288     *z1Ptr = a1<<count;\r
289     *z0Ptr =\r
290         ( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 63 ) );\r
291 \r
292 }\r
293 \r
294 /*----------------------------------------------------------------------------\r
295 | Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' left\r
296 | by the number of bits given in `count'.  Any bits shifted off are lost.\r
297 | The value of `count' must be less than 64.  The result is broken into three\r
298 | 64-bit pieces which are stored at the locations pointed to by `z0Ptr',\r
299 | `z1Ptr', and `z2Ptr'.\r
300 *----------------------------------------------------------------------------*/\r
301 \r
302 INLINE void\r
303  shortShift192Left(\r
304      bits64 a0,\r
305      bits64 a1,\r
306      bits64 a2,\r
307      int16_t count,\r
308      bits64 *z0Ptr,\r
309      bits64 *z1Ptr,\r
310      bits64 *z2Ptr\r
311  )\r
312 {\r
313     bits64 z0, z1, z2;\r
314     int8_t negCount;\r
315 \r
316     z2 = a2<<count;\r
317     z1 = a1<<count;\r
318     z0 = a0<<count;\r
319     if ( 0 < count ) {\r
320         negCount = ( ( - count ) & 63 );\r
321         z1 |= a2>>negCount;\r
322         z0 |= a1>>negCount;\r
323     }\r
324     *z2Ptr = z2;\r
325     *z1Ptr = z1;\r
326     *z0Ptr = z0;\r
327 \r
328 }\r
329 \r
330 /*----------------------------------------------------------------------------\r
331 | Adds the 128-bit value formed by concatenating `a0' and `a1' to the 128-bit\r
332 | value formed by concatenating `b0' and `b1'.  Addition is modulo 2^128, so\r
333 | any carry out is lost.  The result is broken into two 64-bit pieces which\r
334 | are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.\r
335 *----------------------------------------------------------------------------*/\r
336 \r
337 INLINE void\r
338  add128(\r
339      bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )\r
340 {\r
341     bits64 z1;\r
342 \r
343     z1 = a1 + b1;\r
344     *z1Ptr = z1;\r
345     *z0Ptr = a0 + b0 + ( z1 < a1 );\r
346 \r
347 }\r
348 \r
349 /*----------------------------------------------------------------------------\r
350 | Adds the 192-bit value formed by concatenating `a0', `a1', and `a2' to the\r
351 | 192-bit value formed by concatenating `b0', `b1', and `b2'.  Addition is\r
352 | modulo 2^192, so any carry out is lost.  The result is broken into three\r
353 | 64-bit pieces which are stored at the locations pointed to by `z0Ptr',\r
354 | `z1Ptr', and `z2Ptr'.\r
355 *----------------------------------------------------------------------------*/\r
356 \r
357 INLINE void\r
358  add192(\r
359      bits64 a0,\r
360      bits64 a1,\r
361      bits64 a2,\r
362      bits64 b0,\r
363      bits64 b1,\r
364      bits64 b2,\r
365      bits64 *z0Ptr,\r
366      bits64 *z1Ptr,\r
367      bits64 *z2Ptr\r
368  )\r
369 {\r
370     bits64 z0, z1, z2;\r
371     int8_t carry0, carry1;\r
372 \r
373     z2 = a2 + b2;\r
374     carry1 = ( z2 < a2 );\r
375     z1 = a1 + b1;\r
376     carry0 = ( z1 < a1 );\r
377     z0 = a0 + b0;\r
378     z1 += carry1;\r
379     z0 += ( z1 < carry1 );\r
380     z0 += carry0;\r
381     *z2Ptr = z2;\r
382     *z1Ptr = z1;\r
383     *z0Ptr = z0;\r
384 \r
385 }\r
386 \r
387 /*----------------------------------------------------------------------------\r
388 | Subtracts the 128-bit value formed by concatenating `b0' and `b1' from the\r
389 | 128-bit value formed by concatenating `a0' and `a1'.  Subtraction is modulo\r
390 | 2^128, so any borrow out (carry out) is lost.  The result is broken into two\r
391 | 64-bit pieces which are stored at the locations pointed to by `z0Ptr' and\r
392 | `z1Ptr'.\r
393 *----------------------------------------------------------------------------*/\r
394 \r
395 INLINE void\r
396  sub128(\r
397      bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )\r
398 {\r
399 \r
400     *z1Ptr = a1 - b1;\r
401     *z0Ptr = a0 - b0 - ( a1 < b1 );\r
402 \r
403 }\r
404 \r
405 /*----------------------------------------------------------------------------\r
406 | Subtracts the 192-bit value formed by concatenating `b0', `b1', and `b2'\r
407 | from the 192-bit value formed by concatenating `a0', `a1', and `a2'.\r
408 | Subtraction is modulo 2^192, so any borrow out (carry out) is lost.  The\r
409 | result is broken into three 64-bit pieces which are stored at the locations\r
410 | pointed to by `z0Ptr', `z1Ptr', and `z2Ptr'.\r
411 *----------------------------------------------------------------------------*/\r
412 \r
413 INLINE void\r
414  sub192(\r
415      bits64 a0,\r
416      bits64 a1,\r
417      bits64 a2,\r
418      bits64 b0,\r
419      bits64 b1,\r
420      bits64 b2,\r
421      bits64 *z0Ptr,\r
422      bits64 *z1Ptr,\r
423      bits64 *z2Ptr\r
424  )\r
425 {\r
426     bits64 z0, z1, z2;\r
427     int8_t borrow0, borrow1;\r
428 \r
429     z2 = a2 - b2;\r
430     borrow1 = ( a2 < b2 );\r
431     z1 = a1 - b1;\r
432     borrow0 = ( a1 < b1 );\r
433     z0 = a0 - b0;\r
434     z0 -= ( z1 < borrow1 );\r
435     z1 -= borrow1;\r
436     z0 -= borrow0;\r
437     *z2Ptr = z2;\r
438     *z1Ptr = z1;\r
439     *z0Ptr = z0;\r
440 \r
441 }\r
442 \r
443 /*----------------------------------------------------------------------------\r
444 | Multiplies `a' by `b' to obtain a 128-bit product.  The product is broken\r
445 | into two 64-bit pieces which are stored at the locations pointed to by\r
446 | `z0Ptr' and `z1Ptr'.\r
447 *----------------------------------------------------------------------------*/\r
448 \r
449 INLINE void mul64To128( bits64 a, bits64 b, bits64 *z0Ptr, bits64 *z1Ptr )\r
450 {\r
451     bits32 aHigh, aLow, bHigh, bLow;\r
452     bits64 z0, zMiddleA, zMiddleB, z1;\r
453 \r
454     aLow = a;\r
455     aHigh = a>>32;\r
456     bLow = b;\r
457     bHigh = b>>32;\r
458     z1 = ( (bits64) aLow ) * bLow;\r
459     zMiddleA = ( (bits64) aLow ) * bHigh;\r
460     zMiddleB = ( (bits64) aHigh ) * bLow;\r
461     z0 = ( (bits64) aHigh ) * bHigh;\r
462     zMiddleA += zMiddleB;\r
463     z0 += ( ( (bits64) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );\r
464     zMiddleA <<= 32;\r
465     z1 += zMiddleA;\r
466     z0 += ( z1 < zMiddleA );\r
467     *z1Ptr = z1;\r
468     *z0Ptr = z0;\r
469 \r
470 }\r
471 \r
472 /*----------------------------------------------------------------------------\r
473 | Multiplies the 128-bit value formed by concatenating `a0' and `a1' by\r
474 | `b' to obtain a 192-bit product.  The product is broken into three 64-bit\r
475 | pieces which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and\r
476 | `z2Ptr'.\r
477 *----------------------------------------------------------------------------*/\r
478 \r
479 INLINE void\r
480  mul128By64To192(\r
481      bits64 a0,\r
482      bits64 a1,\r
483      bits64 b,\r
484      bits64 *z0Ptr,\r
485      bits64 *z1Ptr,\r
486      bits64 *z2Ptr\r
487  )\r
488 {\r
489     bits64 z0, z1, z2, more1;\r
490 \r
491     mul64To128( a1, b, &z1, &z2 );\r
492     mul64To128( a0, b, &z0, &more1 );\r
493     add128( z0, more1, 0, z1, &z0, &z1 );\r
494     *z2Ptr = z2;\r
495     *z1Ptr = z1;\r
496     *z0Ptr = z0;\r
497 \r
498 }\r
499 \r
500 /*----------------------------------------------------------------------------\r
501 | Multiplies the 128-bit value formed by concatenating `a0' and `a1' to the\r
502 | 128-bit value formed by concatenating `b0' and `b1' to obtain a 256-bit\r
503 | product.  The product is broken into four 64-bit pieces which are stored at\r
504 | the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.\r
505 *----------------------------------------------------------------------------*/\r
506 \r
507 INLINE void\r
508  mul128To256(\r
509      bits64 a0,\r
510      bits64 a1,\r
511      bits64 b0,\r
512      bits64 b1,\r
513      bits64 *z0Ptr,\r
514      bits64 *z1Ptr,\r
515      bits64 *z2Ptr,\r
516      bits64 *z3Ptr\r
517  )\r
518 {\r
519     bits64 z0, z1, z2, z3;\r
520     bits64 more1, more2;\r
521 \r
522     mul64To128( a1, b1, &z2, &z3 );\r
523     mul64To128( a1, b0, &z1, &more2 );\r
524     add128( z1, more2, 0, z2, &z1, &z2 );\r
525     mul64To128( a0, b0, &z0, &more1 );\r
526     add128( z0, more1, 0, z1, &z0, &z1 );\r
527     mul64To128( a0, b1, &more1, &more2 );\r
528     add128( more1, more2, 0, z2, &more1, &z2 );\r
529     add128( z0, z1, 0, more1, &z0, &z1 );\r
530     *z3Ptr = z3;\r
531     *z2Ptr = z2;\r
532     *z1Ptr = z1;\r
533     *z0Ptr = z0;\r
534 \r
535 }\r
536 \r
537 /*----------------------------------------------------------------------------\r
538 | Returns an approximation to the 64-bit integer quotient obtained by dividing\r
539 | `b' into the 128-bit value formed by concatenating `a0' and `a1'.  The\r
540 | divisor `b' must be at least 2^63.  If q is the exact quotient truncated\r
541 | toward zero, the approximation returned lies between q and q + 2 inclusive.\r
542 | If the exact quotient q is larger than 64 bits, the maximum positive 64-bit\r
543 | unsigned integer is returned.\r
544 *----------------------------------------------------------------------------*/\r
545 \r
546 static bits64 estimateDiv128To64( bits64 a0, bits64 a1, bits64 b )\r
547 {\r
548     bits64 b0, b1;\r
549     bits64 rem0, rem1, term0, term1;\r
550     bits64 z;\r
551 \r
552     if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF );\r
553     b0 = b>>32;\r
554     z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32;\r
555     mul64To128( b, z, &term0, &term1 );\r
556     sub128( a0, a1, term0, term1, &rem0, &rem1 );\r
557     while ( ( (sbits64) rem0 ) < 0 ) {\r
558         z -= LIT64( 0x100000000 );\r
559         b1 = b<<32;\r
560         add128( rem0, rem1, b0, b1, &rem0, &rem1 );\r
561     }\r
562     rem0 = ( rem0<<32 ) | ( rem1>>32 );\r
563     z |= ( b0<<32 <= rem0 ) ? 0xFFFFFFFF : rem0 / b0;\r
564     return z;\r
565 \r
566 }\r
567 \r
568 /*----------------------------------------------------------------------------\r
569 | Returns an approximation to the square root of the 32-bit significand given\r
570 | by `a'.  Considered as an integer, `a' must be at least 2^31.  If bit 0 of\r
571 | `aExp' (the least significant bit) is 1, the integer returned approximates\r
572 | 2^31*sqrt(`a'/2^31), where `a' is considered an integer.  If bit 0 of `aExp'\r
573 | is 0, the integer returned approximates 2^31*sqrt(`a'/2^30).  In either\r
574 | case, the approximation returned lies strictly within +/-2 of the exact\r
575 | value.\r
576 *----------------------------------------------------------------------------*/\r
577 \r
578 static bits32 estimateSqrt32( int16_t aExp, bits32 a )\r
579 {\r
580     static const bits16 sqrtOddAdjustments[] = {\r
581         0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,\r
582         0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67\r
583     };\r
584     static const bits16 sqrtEvenAdjustments[] = {\r
585         0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,\r
586         0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002\r
587     };\r
588     int8_t index;\r
589     bits32 z;\r
590 \r
591     index = ( a>>27 ) & 15;\r
592     if ( aExp & 1 ) {\r
593         z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ];\r
594         z = ( ( a / z )<<14 ) + ( z<<15 );\r
595         a >>= 1;\r
596     }\r
597     else {\r
598         z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ];\r
599         z = a / z + z;\r
600         z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );\r
601         if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 );\r
602     }\r
603     return ( (bits32) ( ( ( (bits64) a )<<31 ) / z ) ) + ( z>>1 );\r
604 \r
605 }\r
606 \r
607 /*----------------------------------------------------------------------------\r
608 | Returns the number of leading 0 bits before the most-significant 1 bit of\r
609 | `a'.  If `a' is zero, 32 is returned.\r
610 *----------------------------------------------------------------------------*/\r
611 \r
612 static int8_t countLeadingZeros32( bits32 a )\r
613 {\r
614     static const int8_t countLeadingZerosHigh[] = {\r
615         8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,\r
616         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\r
617         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\r
618         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\r
619         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
620         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
621         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
622         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
623         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
624         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
625         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
626         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
627         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
628         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
629         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
630         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\r
631     };\r
632     int8_t shiftCount;\r
633 \r
634     shiftCount = 0;\r
635     if ( a < 0x10000 ) {\r
636         shiftCount += 16;\r
637         a <<= 16;\r
638     }\r
639     if ( a < 0x1000000 ) {\r
640         shiftCount += 8;\r
641         a <<= 8;\r
642     }\r
643     shiftCount += countLeadingZerosHigh[ a>>24 ];\r
644     return shiftCount;\r
645 \r
646 }\r
647 \r
648 /*----------------------------------------------------------------------------\r
649 | Returns the number of leading 0 bits before the most-significant 1 bit of\r
650 | `a'.  If `a' is zero, 64 is returned.\r
651 *----------------------------------------------------------------------------*/\r
652 \r
653 static int8_t countLeadingZeros64( bits64 a )\r
654 {\r
655     int8_t shiftCount;\r
656 \r
657     shiftCount = 0;\r
658     if ( a < ( (bits64) 1 )<<32 ) {\r
659         shiftCount += 32;\r
660     }\r
661     else {\r
662         a >>= 32;\r
663     }\r
664     shiftCount += countLeadingZeros32( a );\r
665     return shiftCount;\r
666 \r
667 }\r
668 \r
669 /*----------------------------------------------------------------------------\r
670 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1'\r
671 | is equal to the 128-bit value formed by concatenating `b0' and `b1'.\r
672 | Otherwise, returns 0.\r
673 *----------------------------------------------------------------------------*/\r
674 \r
675 INLINE flag eq128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )\r
676 {\r
677 \r
678     return ( a0 == b0 ) && ( a1 == b1 );\r
679 \r
680 }\r
681 \r
682 /*----------------------------------------------------------------------------\r
683 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less\r
684 | than or equal to the 128-bit value formed by concatenating `b0' and `b1'.\r
685 | Otherwise, returns 0.\r
686 *----------------------------------------------------------------------------*/\r
687 \r
688 INLINE flag le128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )\r
689 {\r
690 \r
691     return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );\r
692 \r
693 }\r
694 \r
695 /*----------------------------------------------------------------------------\r
696 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less\r
697 | than the 128-bit value formed by concatenating `b0' and `b1'.  Otherwise,\r
698 | returns 0.\r
699 *----------------------------------------------------------------------------*/\r
700 \r
701 INLINE flag lt128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )\r
702 {\r
703 \r
704     return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );\r
705 \r
706 }\r
707 \r
708 /*----------------------------------------------------------------------------\r
709 | Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is\r
710 | not equal to the 128-bit value formed by concatenating `b0' and `b1'.\r
711 | Otherwise, returns 0.\r
712 *----------------------------------------------------------------------------*/\r
713 \r
714 INLINE flag ne128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )\r
715 {\r
716 \r
717     return ( a0 != b0 ) || ( a1 != b1 );\r
718 \r
719 }\r
720 \r