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 #if defined(TARGET_MIPS) || defined(TARGET_HPPA)
34 #define SNAN_BIT_IS_ONE 1
35 #else
36 #define SNAN_BIT_IS_ONE 0
37 #endif
38
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
float_raise(int8 flags STATUS_PARAM)46 void float_raise( int8 flags STATUS_PARAM )
47 {
48 STATUS(float_exception_flags) |= flags;
49 }
50
51 /*----------------------------------------------------------------------------
52 | Internal canonical NaN format.
53 *----------------------------------------------------------------------------*/
54 typedef struct {
55 flag sign;
56 bits64 high, low;
57 } commonNaNT;
58
59 /*----------------------------------------------------------------------------
60 | The pattern for a default generated single-precision NaN.
61 *----------------------------------------------------------------------------*/
62 #if defined(TARGET_SPARC)
63 #define float32_default_nan make_float32(0x7FFFFFFF)
64 #elif defined(TARGET_POWERPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA)
65 #define float32_default_nan make_float32(0x7FC00000)
66 #elif defined(TARGET_HPPA)
67 #define float32_default_nan make_float32(0x7FA00000)
68 #elif SNAN_BIT_IS_ONE
69 #define float32_default_nan make_float32(0x7FBFFFFF)
70 #else
71 #define float32_default_nan make_float32(0xFFC00000)
72 #endif
73
74 /*----------------------------------------------------------------------------
75 | Returns 1 if the single-precision floating-point value `a' is a quiet
76 | NaN; otherwise returns 0.
77 *----------------------------------------------------------------------------*/
78
float32_is_nan(float32 a_)79 int float32_is_nan( float32 a_ )
80 {
81 uint32_t a = float32_val(a_);
82 #if SNAN_BIT_IS_ONE
83 return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
84 #else
85 return ( 0xFF800000 <= (bits32) ( a<<1 ) );
86 #endif
87 }
88
89 /*----------------------------------------------------------------------------
90 | Returns 1 if the single-precision floating-point value `a' is a signaling
91 | NaN; otherwise returns 0.
92 *----------------------------------------------------------------------------*/
93
float32_is_signaling_nan(float32 a_)94 int float32_is_signaling_nan( float32 a_ )
95 {
96 uint32_t a = float32_val(a_);
97 #if SNAN_BIT_IS_ONE
98 return ( 0xFF800000 <= (bits32) ( a<<1 ) );
99 #else
100 return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
101 #endif
102 }
103
104 /*----------------------------------------------------------------------------
105 | Returns the result of converting the single-precision floating-point NaN
106 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
107 | exception is raised.
108 *----------------------------------------------------------------------------*/
109
float32ToCommonNaN(float32 a STATUS_PARAM)110 static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
111 {
112 commonNaNT z;
113
114 if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR );
115 z.sign = float32_val(a)>>31;
116 z.low = 0;
117 z.high = ( (bits64) float32_val(a) )<<41;
118 return z;
119 }
120
121 /*----------------------------------------------------------------------------
122 | Returns the result of converting the canonical NaN `a' to the single-
123 | precision floating-point format.
124 *----------------------------------------------------------------------------*/
125
commonNaNToFloat32(commonNaNT a)126 static float32 commonNaNToFloat32( commonNaNT a )
127 {
128 bits32 mantissa = a.high>>41;
129 if ( mantissa )
130 return make_float32(
131 ( ( (bits32) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) );
132 else
133 return float32_default_nan;
134 }
135
136 /*----------------------------------------------------------------------------
137 | Takes two single-precision floating-point values `a' and `b', one of which
138 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
139 | signaling NaN, the invalid exception is raised.
140 *----------------------------------------------------------------------------*/
141
propagateFloat32NaN(float32 a,float32 b STATUS_PARAM)142 static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
143 {
144 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
145 bits32 av, bv, res;
146
147 if ( STATUS(default_nan_mode) )
148 return float32_default_nan;
149
150 aIsNaN = float32_is_nan( a );
151 aIsSignalingNaN = float32_is_signaling_nan( a );
152 bIsNaN = float32_is_nan( b );
153 bIsSignalingNaN = float32_is_signaling_nan( b );
154 av = float32_val(a);
155 bv = float32_val(b);
156 #if SNAN_BIT_IS_ONE
157 av &= ~0x00400000;
158 bv &= ~0x00400000;
159 #else
160 av |= 0x00400000;
161 bv |= 0x00400000;
162 #endif
163 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
164 if ( aIsSignalingNaN ) {
165 if ( bIsSignalingNaN ) goto returnLargerSignificand;
166 res = bIsNaN ? bv : av;
167 }
168 else if ( aIsNaN ) {
169 if ( bIsSignalingNaN || ! bIsNaN )
170 res = av;
171 else {
172 returnLargerSignificand:
173 if ( (bits32) ( av<<1 ) < (bits32) ( bv<<1 ) )
174 res = bv;
175 else if ( (bits32) ( bv<<1 ) < (bits32) ( av<<1 ) )
176 res = av;
177 else
178 res = ( av < bv ) ? av : bv;
179 }
180 }
181 else {
182 res = bv;
183 }
184 return make_float32(res);
185 }
186
187 /*----------------------------------------------------------------------------
188 | The pattern for a default generated double-precision NaN.
189 *----------------------------------------------------------------------------*/
190 #if defined(TARGET_SPARC)
191 #define float64_default_nan make_float64(LIT64( 0x7FFFFFFFFFFFFFFF ))
192 #elif defined(TARGET_POWERPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA)
193 #define float64_default_nan make_float64(LIT64( 0x7FF8000000000000 ))
194 #elif defined(TARGET_HPPA)
195 #define float64_default_nan make_float64(LIT64( 0x7FF4000000000000 ))
196 #elif SNAN_BIT_IS_ONE
197 #define float64_default_nan make_float64(LIT64( 0x7FF7FFFFFFFFFFFF ))
198 #else
199 #define float64_default_nan make_float64(LIT64( 0xFFF8000000000000 ))
200 #endif
201
202 /*----------------------------------------------------------------------------
203 | Returns 1 if the double-precision floating-point value `a' is a quiet
204 | NaN; otherwise returns 0.
205 *----------------------------------------------------------------------------*/
206
float64_is_nan(float64 a_)207 int float64_is_nan( float64 a_ )
208 {
209 bits64 a = float64_val(a_);
210 #if SNAN_BIT_IS_ONE
211 return
212 ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
213 && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
214 #else
215 return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) );
216 #endif
217 }
218
219 /*----------------------------------------------------------------------------
220 | Returns 1 if the double-precision floating-point value `a' is a signaling
221 | NaN; otherwise returns 0.
222 *----------------------------------------------------------------------------*/
223
float64_is_signaling_nan(float64 a_)224 int float64_is_signaling_nan( float64 a_ )
225 {
226 bits64 a = float64_val(a_);
227 #if SNAN_BIT_IS_ONE
228 return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) );
229 #else
230 return
231 ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
232 && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
233 #endif
234 }
235
236 /*----------------------------------------------------------------------------
237 | Returns the result of converting the double-precision floating-point NaN
238 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
239 | exception is raised.
240 *----------------------------------------------------------------------------*/
241
float64ToCommonNaN(float64 a STATUS_PARAM)242 static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
243 {
244 commonNaNT z;
245
246 if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
247 z.sign = float64_val(a)>>63;
248 z.low = 0;
249 z.high = float64_val(a)<<12;
250 return z;
251 }
252
253 /*----------------------------------------------------------------------------
254 | Returns the result of converting the canonical NaN `a' to the double-
255 | precision floating-point format.
256 *----------------------------------------------------------------------------*/
257
commonNaNToFloat64(commonNaNT a)258 static float64 commonNaNToFloat64( commonNaNT a )
259 {
260 bits64 mantissa = a.high>>12;
261
262 if ( mantissa )
263 return make_float64(
264 ( ( (bits64) a.sign )<<63 )
265 | LIT64( 0x7FF0000000000000 )
266 | ( a.high>>12 ));
267 else
268 return float64_default_nan;
269 }
270
271 /*----------------------------------------------------------------------------
272 | Takes two double-precision floating-point values `a' and `b', one of which
273 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
274 | signaling NaN, the invalid exception is raised.
275 *----------------------------------------------------------------------------*/
276
propagateFloat64NaN(float64 a,float64 b STATUS_PARAM)277 static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
278 {
279 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
280 bits64 av, bv, res;
281
282 if ( STATUS(default_nan_mode) )
283 return float64_default_nan;
284
285 aIsNaN = float64_is_nan( a );
286 aIsSignalingNaN = float64_is_signaling_nan( a );
287 bIsNaN = float64_is_nan( b );
288 bIsSignalingNaN = float64_is_signaling_nan( b );
289 av = float64_val(a);
290 bv = float64_val(b);
291 #if SNAN_BIT_IS_ONE
292 av &= ~LIT64( 0x0008000000000000 );
293 bv &= ~LIT64( 0x0008000000000000 );
294 #else
295 av |= LIT64( 0x0008000000000000 );
296 bv |= LIT64( 0x0008000000000000 );
297 #endif
298 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
299 if ( aIsSignalingNaN ) {
300 if ( bIsSignalingNaN ) goto returnLargerSignificand;
301 res = bIsNaN ? bv : av;
302 }
303 else if ( aIsNaN ) {
304 if ( bIsSignalingNaN || ! bIsNaN )
305 res = av;
306 else {
307 returnLargerSignificand:
308 if ( (bits64) ( av<<1 ) < (bits64) ( bv<<1 ) )
309 res = bv;
310 else if ( (bits64) ( bv<<1 ) < (bits64) ( av<<1 ) )
311 res = av;
312 else
313 res = ( av < bv ) ? av : bv;
314 }
315 }
316 else {
317 res = bv;
318 }
319 return make_float64(res);
320 }
321
322 #ifdef FLOATX80
323
324 /*----------------------------------------------------------------------------
325 | The pattern for a default generated extended double-precision NaN. The
326 | `high' and `low' values hold the most- and least-significant bits,
327 | respectively.
328 *----------------------------------------------------------------------------*/
329 #if SNAN_BIT_IS_ONE
330 #define floatx80_default_nan_high 0x7FFF
331 #define floatx80_default_nan_low LIT64( 0xBFFFFFFFFFFFFFFF )
332 #else
333 #define floatx80_default_nan_high 0xFFFF
334 #define floatx80_default_nan_low LIT64( 0xC000000000000000 )
335 #endif
336
337 /*----------------------------------------------------------------------------
338 | Returns 1 if the extended double-precision floating-point value `a' is a
339 | quiet NaN; otherwise returns 0.
340 *----------------------------------------------------------------------------*/
341
floatx80_is_nan(floatx80 a)342 int floatx80_is_nan( floatx80 a )
343 {
344 #if SNAN_BIT_IS_ONE
345 bits64 aLow;
346
347 aLow = a.low & ~ LIT64( 0x4000000000000000 );
348 return
349 ( ( a.high & 0x7FFF ) == 0x7FFF )
350 && (bits64) ( aLow<<1 )
351 && ( a.low == aLow );
352 #else
353 return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
354 #endif
355 }
356
357 /*----------------------------------------------------------------------------
358 | Returns 1 if the extended double-precision floating-point value `a' is a
359 | signaling NaN; otherwise returns 0.
360 *----------------------------------------------------------------------------*/
361
floatx80_is_signaling_nan(floatx80 a)362 int floatx80_is_signaling_nan( floatx80 a )
363 {
364 #if SNAN_BIT_IS_ONE
365 return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
366 #else
367 bits64 aLow;
368
369 aLow = a.low & ~ LIT64( 0x4000000000000000 );
370 return
371 ( ( a.high & 0x7FFF ) == 0x7FFF )
372 && (bits64) ( aLow<<1 )
373 && ( a.low == aLow );
374 #endif
375 }
376
377 /*----------------------------------------------------------------------------
378 | Returns the result of converting the extended double-precision floating-
379 | point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
380 | invalid exception is raised.
381 *----------------------------------------------------------------------------*/
382
floatx80ToCommonNaN(floatx80 a STATUS_PARAM)383 static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
384 {
385 commonNaNT z;
386
387 if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
388 z.sign = a.high>>15;
389 z.low = 0;
390 z.high = a.low;
391 return z;
392 }
393
394 /*----------------------------------------------------------------------------
395 | Returns the result of converting the canonical NaN `a' to the extended
396 | double-precision floating-point format.
397 *----------------------------------------------------------------------------*/
398
commonNaNToFloatx80(commonNaNT a)399 static floatx80 commonNaNToFloatx80( commonNaNT a )
400 {
401 floatx80 z;
402
403 if (a.high)
404 z.low = a.high;
405 else
406 z.low = floatx80_default_nan_low;
407 z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
408 return z;
409 }
410
411 /*----------------------------------------------------------------------------
412 | Takes two extended double-precision floating-point values `a' and `b', one
413 | of which is a NaN, and returns the appropriate NaN result. If either `a' or
414 | `b' is a signaling NaN, the invalid exception is raised.
415 *----------------------------------------------------------------------------*/
416
propagateFloatx80NaN(floatx80 a,floatx80 b STATUS_PARAM)417 static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b STATUS_PARAM)
418 {
419 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
420
421 if ( STATUS(default_nan_mode) ) {
422 a.low = floatx80_default_nan_low;
423 a.high = floatx80_default_nan_high;
424 return a;
425 }
426
427 aIsNaN = floatx80_is_nan( a );
428 aIsSignalingNaN = floatx80_is_signaling_nan( a );
429 bIsNaN = floatx80_is_nan( b );
430 bIsSignalingNaN = floatx80_is_signaling_nan( b );
431 #if SNAN_BIT_IS_ONE
432 a.low &= ~LIT64( 0xC000000000000000 );
433 b.low &= ~LIT64( 0xC000000000000000 );
434 #else
435 a.low |= LIT64( 0xC000000000000000 );
436 b.low |= LIT64( 0xC000000000000000 );
437 #endif
438 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
439 if ( aIsSignalingNaN ) {
440 if ( bIsSignalingNaN ) goto returnLargerSignificand;
441 return bIsNaN ? b : a;
442 }
443 else if ( aIsNaN ) {
444 if ( bIsSignalingNaN || ! bIsNaN ) return a;
445 returnLargerSignificand:
446 if ( a.low < b.low ) return b;
447 if ( b.low < a.low ) return a;
448 return ( a.high < b.high ) ? a : b;
449 }
450 else {
451 return b;
452 }
453 }
454
455 #endif
456
457 #ifdef FLOAT128
458
459 /*----------------------------------------------------------------------------
460 | The pattern for a default generated quadruple-precision NaN. The `high' and
461 | `low' values hold the most- and least-significant bits, respectively.
462 *----------------------------------------------------------------------------*/
463 #if SNAN_BIT_IS_ONE
464 #define float128_default_nan_high LIT64( 0x7FFF7FFFFFFFFFFF )
465 #define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF )
466 #else
467 #define float128_default_nan_high LIT64( 0xFFFF800000000000 )
468 #define float128_default_nan_low LIT64( 0x0000000000000000 )
469 #endif
470
471 /*----------------------------------------------------------------------------
472 | Returns 1 if the quadruple-precision floating-point value `a' is a quiet
473 | NaN; otherwise returns 0.
474 *----------------------------------------------------------------------------*/
475
float128_is_nan(float128 a)476 int float128_is_nan( float128 a )
477 {
478 #if SNAN_BIT_IS_ONE
479 return
480 ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
481 && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
482 #else
483 return
484 ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
485 && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
486 #endif
487 }
488
489 /*----------------------------------------------------------------------------
490 | Returns 1 if the quadruple-precision floating-point value `a' is a
491 | signaling NaN; otherwise returns 0.
492 *----------------------------------------------------------------------------*/
493
float128_is_signaling_nan(float128 a)494 int float128_is_signaling_nan( float128 a )
495 {
496 #if SNAN_BIT_IS_ONE
497 return
498 ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
499 && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
500 #else
501 return
502 ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
503 && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
504 #endif
505 }
506
507 /*----------------------------------------------------------------------------
508 | Returns the result of converting the quadruple-precision floating-point NaN
509 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
510 | exception is raised.
511 *----------------------------------------------------------------------------*/
512
float128ToCommonNaN(float128 a STATUS_PARAM)513 static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM)
514 {
515 commonNaNT z;
516
517 if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
518 z.sign = a.high>>63;
519 shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
520 return z;
521 }
522
523 /*----------------------------------------------------------------------------
524 | Returns the result of converting the canonical NaN `a' to the quadruple-
525 | precision floating-point format.
526 *----------------------------------------------------------------------------*/
527
commonNaNToFloat128(commonNaNT a)528 static float128 commonNaNToFloat128( commonNaNT a )
529 {
530 float128 z;
531
532 shift128Right( a.high, a.low, 16, &z.high, &z.low );
533 z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 );
534 return z;
535 }
536
537 /*----------------------------------------------------------------------------
538 | Takes two quadruple-precision floating-point values `a' and `b', one of
539 | which is a NaN, and returns the appropriate NaN result. If either `a' or
540 | `b' is a signaling NaN, the invalid exception is raised.
541 *----------------------------------------------------------------------------*/
542
propagateFloat128NaN(float128 a,float128 b STATUS_PARAM)543 static float128 propagateFloat128NaN( float128 a, float128 b STATUS_PARAM)
544 {
545 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
546
547 if ( STATUS(default_nan_mode) ) {
548 a.low = float128_default_nan_low;
549 a.high = float128_default_nan_high;
550 return a;
551 }
552
553 aIsNaN = float128_is_nan( a );
554 aIsSignalingNaN = float128_is_signaling_nan( a );
555 bIsNaN = float128_is_nan( b );
556 bIsSignalingNaN = float128_is_signaling_nan( b );
557 #if SNAN_BIT_IS_ONE
558 a.high &= ~LIT64( 0x0000800000000000 );
559 b.high &= ~LIT64( 0x0000800000000000 );
560 #else
561 a.high |= LIT64( 0x0000800000000000 );
562 b.high |= LIT64( 0x0000800000000000 );
563 #endif
564 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
565 if ( aIsSignalingNaN ) {
566 if ( bIsSignalingNaN ) goto returnLargerSignificand;
567 return bIsNaN ? b : a;
568 }
569 else if ( aIsNaN ) {
570 if ( bIsSignalingNaN || ! bIsNaN ) return a;
571 returnLargerSignificand:
572 if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;
573 if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;
574 return ( a.high < b.high ) ? a : b;
575 }
576 else {
577 return b;
578 }
579 }
580
581 #endif
582