![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to softfloat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src / cpu / softfloat|
Return to softfloat.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / cpu / softfloat |
1.1 root 1:
2: #define SOFTFLOAT_68K
3:
4: #include <stdint.h>
5: #include <stdlib.h>
6: #include "softfloat/softfloat.h"
7:
8:
9: /*
10: * QEMU float support
11: *
12: * The code in this source file is derived from release 2a of the SoftFloat
13: * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and
14: * some later contributions) are provided under that license, as detailed below.
15: * It has subsequently been modified by contributors to the QEMU Project,
16: * so some portions are provided under:
17: * the SoftFloat-2a license
18: * the BSD license
19: * GPL-v2-or-later
20: *
21: * Any future contributions to this file after December 1st 2014 will be
22: * taken to be licensed under the Softfloat-2a license unless specifically
23: * indicated otherwise.
24: */
25:
26: /*
27: ===============================================================================
28: This C source file is part of the SoftFloat IEC/IEEE Floating-point
29: Arithmetic Package, Release 2a.
30:
31: Written by John R. Hauser. This work was made possible in part by the
32: International Computer Science Institute, located at Suite 600, 1947 Center
33: Street, Berkeley, California 94704. Funding was partially provided by the
34: National Science Foundation under grant MIP-9311980. The original version
35: of this code was written as part of a project to build a fixed-point vector
36: processor in collaboration with the University of California at Berkeley,
37: overseen by Profs. Nelson Morgan and John Wawrzynek. More information
38: is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
39: arithmetic/SoftFloat.html'.
40:
41: THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
42: has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
43: TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
44: PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
45: AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
46:
47: Derivative works are acceptable, even for commercial purposes, so long as
48: (1) they include prominent notice that the work is derivative, and (2) they
49: include prominent notice akin to these four paragraphs for those parts of
50: this code that are retained.
51:
52: ===============================================================================
53: */
54:
55: /* BSD licensing:
56: * Copyright (c) 2006, Fabrice Bellard
57: * All rights reserved.
58: *
59: * Redistribution and use in source and binary forms, with or without
60: * modification, are permitted provided that the following conditions are met:
61: *
62: * 1. Redistributions of source code must retain the above copyright notice,
63: * this list of conditions and the following disclaimer.
64: *
65: * 2. Redistributions in binary form must reproduce the above copyright notice,
66: * this list of conditions and the following disclaimer in the documentation
67: * and/or other materials provided with the distribution.
68: *
69: * 3. Neither the name of the copyright holder nor the names of its contributors
70: * may be used to endorse or promote products derived from this software without
71: * specific prior written permission.
72: *
73: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
74: * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
75: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
76: * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
77: * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
78: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
79: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
80: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
81: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
82: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
83: * THE POSSIBILITY OF SUCH DAMAGE.
84: */
85:
86: /* Portions of this work are licensed under the terms of the GNU GPL,
87: * version 2 or later. See the COPYING file in the top-level directory.
88: */
89:
90: /* We only need stdlib for abort() */
91:
92: /*----------------------------------------------------------------------------
93: | Primitive arithmetic functions, including multi-word arithmetic, and
94: | division and square root approximations. (Can be specialized to target if
95: | desired.)
96: *----------------------------------------------------------------------------*/
97: #include "softfloat-macros.h"
98:
99: /*----------------------------------------------------------------------------
100: | Variables for storing sign, exponent and significand of internal extended
101: | double-precision floating-point value for external use.
102: *----------------------------------------------------------------------------*/
103: flag floatx80_internal_sign = 0;
104: int32_t floatx80_internal_exp = 0;
105: uint64_t floatx80_internal_sig = 0;
106: int32_t floatx80_internal_exp0 = 0;
107: uint64_t floatx80_internal_sig0 = 0;
108: uint64_t floatx80_internal_sig1 = 0;
109: int8_t floatx80_internal_precision = 80;
110: int8_t floatx80_internal_mode = float_round_nearest_even;
111:
112: /*----------------------------------------------------------------------------
113: | Functions for storing sign, exponent and significand of extended
114: | double-precision floating-point intermediate result for external use.
115: *----------------------------------------------------------------------------*/
116: floatx80 roundSaveFloatx80Internal( int8_t roundingPrecision, flag zSign, int32_t zExp, uint64_t zSig0, uint64_t zSig1, float_status *status )
117: {
118: int64_t roundIncrement, roundMask, roundBits;
119: flag increment;
120:
121: if ( roundingPrecision == 80 ) {
122: goto precision80;
123: } else if ( roundingPrecision == 64 ) {
124: roundIncrement = LIT64( 0x0000000000000400 );
125: roundMask = LIT64( 0x00000000000007FF );
126: } else if ( roundingPrecision == 32 ) {
127: roundIncrement = LIT64( 0x0000008000000000 );
128: roundMask = LIT64( 0x000000FFFFFFFFFF );
129: } else {
130: goto precision80;
131: }
132:
133: zSig0 |= ( zSig1 != 0 );
134: if ( status->float_rounding_mode != float_round_nearest_even ) {
135: if ( status->float_rounding_mode == float_round_to_zero ) {
136: roundIncrement = 0;
137: } else {
138: roundIncrement = roundMask;
139: if ( zSign ) {
140: if ( status->float_rounding_mode == float_round_up ) roundIncrement = 0;
141: } else {
142: if ( status->float_rounding_mode == float_round_down ) roundIncrement = 0;
143: }
144: }
145: }
146:
147: roundBits = zSig0 & roundMask;
148:
149: zSig0 += roundIncrement;
150: if ( zSig0 < roundIncrement ) {
151: ++zExp;
152: zSig0 = LIT64( 0x8000000000000000 );
153: }
154: roundIncrement = roundMask + 1;
155: if ( status->float_rounding_mode == float_round_nearest_even && ( roundBits<<1 == roundIncrement ) ) {
156: roundMask |= roundIncrement;
157: }
158: zSig0 &= ~ roundMask;
159: if ( zSig0 == 0 ) zExp = 0;
160: return packFloatx80( zSign, zExp, zSig0 );
161:
162: precision80:
163: increment = ( (int64_t) zSig1 < 0 );
164: if ( status->float_rounding_mode != float_round_nearest_even ) {
165: if ( status->float_rounding_mode == float_round_to_zero ) {
166: increment = 0;
167: } else {
168: if ( zSign ) {
169: increment = ( status->float_rounding_mode == float_round_down ) && zSig1;
170: } else {
171: increment = ( status->float_rounding_mode == float_round_up ) && zSig1;
172: }
173: }
174: }
175: if ( increment ) {
176: ++zSig0;
177: if ( zSig0 == 0 ) {
178: ++zExp;
179: zSig0 = LIT64( 0x8000000000000000 );
180: } else {
181: zSig0 &= ~ ( ( (uint64_t) ( zSig1<<1 ) == 0 ) & ( status->float_rounding_mode == float_round_nearest_even ) );
182: }
183: } else {
184: if ( zSig0 == 0 ) zExp = 0;
185: }
186: return packFloatx80( zSign, zExp, zSig0 );
187: }
188:
189: static void saveFloatx80Internal( int8_t prec, flag zSign, int32_t zExp, uint64_t zSig0, uint64_t zSig1, float_status *status )
190: {
191: floatx80_internal_sign = zSign;
192: floatx80_internal_exp = zExp;
193: floatx80_internal_sig0 = zSig0;
194: floatx80_internal_sig1 = zSig1;
195: floatx80_internal_precision = prec;
196: floatx80_internal_mode = status->float_rounding_mode;
197: }
198:
199: static void saveFloat64Internal( flag zSign, int16_t zExp, uint64_t zSig, float_status *status )
200: {
201: floatx80_internal_sign = zSign;
202: floatx80_internal_exp = zExp + 0x3C01;
203: floatx80_internal_sig0 = zSig<<1;
204: floatx80_internal_sig1 = 0;
205: floatx80_internal_precision = 64;
206: floatx80_internal_mode = status->float_rounding_mode;
207: }
208:
209: static void saveFloat32Internal( flag zSign, int16_t zExp, uint32_t zSig, float_status *status )
210: {
211: floatx80 z = roundSaveFloatx80Internal( 32, zSign, zExp + 0x3F81, ( (uint64_t) zSig )<<33, 0, status );
212:
213: floatx80_internal_sign = zSign;
214: floatx80_internal_exp = extractFloatx80Exp( z );
215: floatx80_internal_sig = extractFloatx80Frac( z );
216: floatx80_internal_exp0 = zExp + 0x3F81;
217: floatx80_internal_sig0 = ( (uint64_t) zSig )<<33;
218: floatx80_internal_sig1 = 0;
219: }
220:
221: /*----------------------------------------------------------------------------
222: | Functions for returning sign, exponent and significand of extended
223: | double-precision floating-point intermediate result for external use.
224: *----------------------------------------------------------------------------*/
225:
226: void getRoundedFloatInternal( int8_t roundingPrecision, flag *pzSign, int32_t *pzExp, uint64_t *pzSig )
227: {
228: int64_t roundIncrement, roundMask, roundBits;
229: flag increment;
230:
231: flag zSign = floatx80_internal_sign;
232: int32_t zExp = floatx80_internal_exp;
233: uint64_t zSig0 = floatx80_internal_sig0;
234: uint64_t zSig1 = floatx80_internal_sig1;
235:
236: if ( roundingPrecision == 80 ) {
237: goto precision80;
238: } else if ( roundingPrecision == 64 ) {
239: roundIncrement = LIT64( 0x0000000000000400 );
240: roundMask = LIT64( 0x00000000000007FF );
241: } else if ( roundingPrecision == 32 ) {
242: roundIncrement = LIT64( 0x0000008000000000 );
243: roundMask = LIT64( 0x000000FFFFFFFFFF );
244: } else {
245: goto precision80;
246: }
247:
248: zSig0 |= ( zSig1 != 0 );
249: if ( floatx80_internal_mode != float_round_nearest_even ) {
250: if ( floatx80_internal_mode == float_round_to_zero ) {
251: roundIncrement = 0;
252: } else {
253: roundIncrement = roundMask;
254: if ( zSign ) {
255: if ( floatx80_internal_mode == float_round_up ) roundIncrement = 0;
256: } else {
257: if ( floatx80_internal_mode == float_round_down ) roundIncrement = 0;
258: }
259: }
260: }
261:
262: roundBits = zSig0 & roundMask;
263:
264: zSig0 += roundIncrement;
265: if ( zSig0 < roundIncrement ) {
266: ++zExp;
267: zSig0 = LIT64( 0x8000000000000000 );
268: }
269: roundIncrement = roundMask + 1;
270: if ( floatx80_internal_mode == float_round_nearest_even && ( roundBits<<1 == roundIncrement ) ) {
271: roundMask |= roundIncrement;
272: }
273: zSig0 &= ~ roundMask;
274: if ( zSig0 == 0 ) zExp = 0;
275:
276: *pzSign = zSign;
277: *pzExp = zExp;
278: *pzSig = zSig0;
279: return;
280:
281: precision80:
282: increment = ( (int64_t) zSig1 < 0 );
283: if ( floatx80_internal_mode != float_round_nearest_even ) {
284: if ( floatx80_internal_mode == float_round_to_zero ) {
285: increment = 0;
286: } else {
287: if ( zSign ) {
288: increment = ( floatx80_internal_mode == float_round_down ) && zSig1;
289: } else {
290: increment = ( floatx80_internal_mode == float_round_up ) && zSig1;
291: }
292: }
293: }
294: if ( increment ) {
295: ++zSig0;
296: if ( zSig0 == 0 ) {
297: ++zExp;
298: zSig0 = LIT64( 0x8000000000000000 );
299: } else {
300: zSig0 &= ~ ( ( (uint64_t) ( zSig1<<1 ) == 0 ) & ( floatx80_internal_mode == float_round_nearest_even ) );
301: }
302: } else {
303: if ( zSig0 == 0 ) zExp = 0;
304: }
305:
306: *pzSign = zSign;
307: *pzExp = zExp;
308: *pzSig = zSig0;
309: }
310:
311: floatx80 getFloatInternalOverflow( void )
312: {
313: flag zSign;
314: int32_t zExp;
315: uint64_t zSig;
316:
317: getRoundedFloatInternal( floatx80_internal_precision, &zSign, &zExp, &zSig );
318:
319: if (zExp > (0x7fff + 0x6000)) { // catastrophic
320: zExp = 0;
321: } else {
322: zExp -= 0x6000;
323: }
324:
325: return packFloatx80( zSign, zExp, zSig );
326:
327: }
328:
329: floatx80 getFloatInternalUnderflow( void )
330: {
331: flag zSign;
332: int32_t zExp;
333: uint64_t zSig;
334:
335: getRoundedFloatInternal( floatx80_internal_precision, &zSign, &zExp, &zSig );
336:
337: if (zExp < (0x0000 - 0x6000)) { // catastrophic
338: zExp = 0;
339: } else {
340: zExp += 0x6000;
341: }
342:
343: return packFloatx80( zSign, zExp, zSig );
344:
345: }
346:
347: floatx80 getFloatInternalRoundedAll( void )
348: {
349: flag zSign;
350: int32_t zExp;
351: uint64_t zSig, zSig32, zSig64, zSig80;
352:
353: if (floatx80_internal_precision == 80) {
354: getRoundedFloatInternal( 80, &zSign, &zExp, &zSig80 );
355: zSig = zSig80;
356: } else if (floatx80_internal_precision == 64) {
357: getRoundedFloatInternal( 80, &zSign, &zExp, &zSig80 );
358: getRoundedFloatInternal( 64, &zSign, &zExp, &zSig64 );
359: zSig = zSig64;
360: zSig |= zSig80 & LIT64( 0x00000000000007FF );
361: } else {
362: getRoundedFloatInternal( 80, &zSign, &zExp, &zSig80 );
363: getRoundedFloatInternal( 64, &zSign, &zExp, &zSig64 );
364: getRoundedFloatInternal( 32, &zSign, &zExp, &zSig32 );
365: zSig = zSig32;
366: zSig |= zSig64 & LIT64( 0x000000FFFFFFFFFF );
367: zSig |= zSig80 & LIT64( 0x00000000000007FF );
368: }
369:
370: return packFloatx80( zSign, zExp & 0x7FFF, zSig );
371:
372: }
373:
374: floatx80 getFloatInternalRoundedSome( void )
375: {
376: flag zSign;
377: int32_t zExp;
378: uint64_t zSig, zSig32, zSig64, zSig80;
379:
380: if (floatx80_internal_precision == 80) {
381: getRoundedFloatInternal( 80, &zSign, &zExp, &zSig80 );
382: zSig = zSig80;
383: } else if (floatx80_internal_precision == 64) {
384: getRoundedFloatInternal( 64, &zSign, &zExp, &zSig64 );
385: zSig80 = floatx80_internal_sig0;
386: if (zSig64 != (zSig80 & LIT64( 0xFFFFFFFFFFFFF800 ))) {
387: zSig80++;
388: }
389: zSig = zSig64;
390: zSig |= zSig80 & LIT64( 0x00000000000007FF );
391: } else {
392: getRoundedFloatInternal( 32, &zSign, &zExp, &zSig32 );
393: zSig80 = floatx80_internal_sig0;
394: if (zSig32 != (zSig80 & LIT64( 0xFFFFFF0000000000 ))) {
395: zSig80++;
396: }
397: zSig = zSig32;
398: zSig |= zSig80 & LIT64( 0x000000FFFFFFFFFF );
399: }
400:
401: return packFloatx80( zSign, zExp & 0x7FFF, zSig );
402:
403: }
404:
405: floatx80 getFloatInternalFloatx80( void )
406: {
407: flag zSign;
408: int32_t zExp;
409: uint64_t zSig;
410:
411: getRoundedFloatInternal( 80, &zSign, &zExp, &zSig );
412:
413: return packFloatx80( zSign, zExp & 0x7FFF, zSig );
414:
415: }
416:
417: floatx80 getFloatInternalUnrounded( void )
418: {
419: flag zSign = floatx80_internal_sign;
420: int32_t zExp = floatx80_internal_exp;
421: uint64_t zSig = floatx80_internal_sig0;
422:
423: return packFloatx80( zSign, zExp & 0x7FFF, zSig );
424:
425: }
426:
427: uint64_t getFloatInternalGRS( void )
428: {
429: #if 1
430: if (floatx80_internal_sig1)
431: return 5;
432:
433: if (floatx80_internal_precision == 64 &&
434: floatx80_internal_sig0 & LIT64( 0x00000000000007FF )) {
435: return 1;
436: }
437: if (floatx80_internal_precision == 32 &&
438: floatx80_internal_sig0 & LIT64( 0x000000FFFFFFFFFF )) {
439: return 1;
440: }
441:
442: return 0;
443: #else
444: uint64_t roundbits;
445: shift64RightJamming(floatx80_internal_sig1, 61, &roundbits);
446:
447: return roundbits;
448: #endif
449: }
450:
451: /*----------------------------------------------------------------------------
452: | Functions and definitions to determine: (1) whether tininess for underflow
453: | is detected before or after rounding by default, (2) what (if anything)
454: | happens when exceptions are raised, (3) how signaling NaNs are distinguished
455: | from quiet NaNs, (4) the default generated quiet NaNs, and (5) how NaNs
456: | are propagated from function inputs to output. These details are target-
457: | specific.
458: *----------------------------------------------------------------------------*/
459: #include "softfloat-specialize.h"
460:
461: /*----------------------------------------------------------------------------
462: | Takes a 64-bit fixed-point value `absZ' with binary point between bits 6
463: | and 7, and returns the properly rounded 32-bit integer corresponding to the
464: | input. If `zSign' is 1, the input is negated before being converted to an
465: | integer. Bit 63 of `absZ' must be zero. Ordinarily, the fixed-point input
466: | is simply rounded to an integer, with the inexact exception raised if the
467: | input cannot be represented exactly as an integer. However, if the fixed-
468: | point input is too large, the invalid exception is raised and the largest
469: | positive or negative integer is returned.
470: *----------------------------------------------------------------------------*/
471:
472: static int32_t roundAndPackInt32(flag zSign, uint64_t absZ, float_status *status)
473: {
474: int8_t roundingMode;
475: flag roundNearestEven;
476: int8_t roundIncrement, roundBits;
477: int32_t z;
478:
479: roundingMode = status->float_rounding_mode;
480: roundNearestEven = ( roundingMode == float_round_nearest_even );
481: switch (roundingMode) {
482: case float_round_nearest_even:
483: case float_round_ties_away:
484: roundIncrement = 0x40;
485: break;
486: case float_round_to_zero:
487: roundIncrement = 0;
488: break;
489: case float_round_up:
490: roundIncrement = zSign ? 0 : 0x7f;
491: break;
492: case float_round_down:
493: roundIncrement = zSign ? 0x7f : 0;
494: break;
495: default:
496: abort();
497: }
498: roundBits = absZ & 0x7F;
499: absZ = ( absZ + roundIncrement )>>7;
500: absZ &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
501: z = absZ;
502: if ( zSign ) z = - z;
503: if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
504: float_raise(float_flag_invalid, status);
505: return zSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
506: }
507: if (roundBits) {
508: status->float_exception_flags |= float_flag_inexact;
509: }
510: return z;
511:
512: }
513:
514:
515: #ifdef SOFTFLOAT_68K // 30-01-2017: Added for Previous
516: static int16_t roundAndPackInt16( flag zSign, uint64_t absZ, float_status *status )
517: {
518: int8_t roundingMode;
519: flag roundNearestEven;
520: int8_t roundIncrement, roundBits;
521: int16_t z;
522:
523: roundingMode = status->float_rounding_mode;
524: roundNearestEven = ( roundingMode == float_round_nearest_even );
525: roundIncrement = 0x40;
526: if ( ! roundNearestEven ) {
527: if ( roundingMode == float_round_to_zero ) {
528: roundIncrement = 0;
529: }
530: else {
531: roundIncrement = 0x7F;
532: if ( zSign ) {
533: if ( roundingMode == float_round_up ) roundIncrement = 0;
534: }
535: else {
536: if ( roundingMode == float_round_down ) roundIncrement = 0;
537: }
538: }
539: }
540: roundBits = absZ & 0x7F;
541: absZ = ( absZ + roundIncrement )>>7;
542: absZ &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
543: z = absZ;
544: if ( zSign ) z = - z;
545: z = (int16_t) z;
546: if ( ( absZ>>16 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
547: float_raise( float_flag_invalid, status );
548: return zSign ? (int16_t) 0x8000 : 0x7FFF;
549: }
550: if ( roundBits ) status->float_exception_flags |= float_flag_inexact;
551: return z;
552:
553: }
554:
555: static int8_t roundAndPackInt8( flag zSign, uint64_t absZ, float_status *status )
556: {
557: int8_t roundingMode;
558: flag roundNearestEven;
559: int8_t roundIncrement, roundBits;
560: int8_t z;
561:
562: roundingMode = status->float_rounding_mode;
563: roundNearestEven = ( roundingMode == float_round_nearest_even );
564: roundIncrement = 0x40;
565: if ( ! roundNearestEven ) {
566: if ( roundingMode == float_round_to_zero ) {
567: roundIncrement = 0;
568: }
569: else {
570: roundIncrement = 0x7F;
571: if ( zSign ) {
572: if ( roundingMode == float_round_up ) roundIncrement = 0;
573: }
574: else {
575: if ( roundingMode == float_round_down ) roundIncrement = 0;
576: }
577: }
578: }
579: roundBits = absZ & 0x7F;
580: absZ = ( absZ + roundIncrement )>>7;
581: absZ &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
582: z = absZ;
583: if ( zSign ) z = - z;
584: z = (int8_t) z;
585: if ( ( absZ>>8 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
586: float_raise( float_flag_invalid, status );
587: return zSign ? (int8_t) 0x80 : 0x7F;
588: }
589: if ( roundBits ) status->float_exception_flags |= float_flag_inexact;
590: return z;
591:
592: }
593: #endif // End of addition for Previous
594:
595: /*----------------------------------------------------------------------------
596: | Takes the 128-bit fixed-point value formed by concatenating `absZ0' and
597: | `absZ1', with binary point between bits 63 and 64 (between the input words),
598: | and returns the properly rounded 64-bit integer corresponding to the input.
599: | If `zSign' is 1, the input is negated before being converted to an integer.
600: | Ordinarily, the fixed-point input is simply rounded to an integer, with
601: | the inexact exception raised if the input cannot be represented exactly as
602: | an integer. However, if the fixed-point input is too large, the invalid
603: | exception is raised and the largest positive or negative integer is
604: | returned.
605: *----------------------------------------------------------------------------*/
606:
607: static int64_t roundAndPackInt64(flag zSign, uint64_t absZ0, uint64_t absZ1,
608: float_status *status)
609: {
610: int8_t roundingMode;
611: flag roundNearestEven, increment;
612: int64_t z;
613:
614: roundingMode = status->float_rounding_mode;
615: roundNearestEven = ( roundingMode == float_round_nearest_even );
616: switch (roundingMode) {
617: case float_round_nearest_even:
618: case float_round_ties_away:
619: increment = ((int64_t) absZ1 < 0);
620: break;
621: case float_round_to_zero:
622: increment = 0;
623: break;
624: case float_round_up:
625: increment = !zSign && absZ1;
626: break;
627: case float_round_down:
628: increment = zSign && absZ1;
629: break;
630: default:
631: abort();
632: }
633: if ( increment ) {
634: ++absZ0;
635: if ( absZ0 == 0 ) goto overflow;
636: absZ0 &= ~ ( ( (uint64_t) ( absZ1<<1 ) == 0 ) & roundNearestEven );
637: }
638: z = absZ0;
639: if ( zSign ) z = - z;
640: if ( z && ( ( z < 0 ) ^ zSign ) ) {
641: overflow:
642: float_raise(float_flag_invalid, status);
643: return
644: zSign ? (int64_t) LIT64( 0x8000000000000000 )
645: : LIT64( 0x7FFFFFFFFFFFFFFF );
646: }
647: if (absZ1) {
648: status->float_exception_flags |= float_flag_inexact;
649: }
650: return z;
651:
652: }
653:
654: /*----------------------------------------------------------------------------
655: | Returns the fraction bits of the single-precision floating-point value `a'.
656: *----------------------------------------------------------------------------*/
657:
658: static inline uint32_t extractFloat32Frac( float32 a )
659: {
660:
661: return float32_val(a) & 0x007FFFFF;
662:
663: }
664:
665: /*----------------------------------------------------------------------------
666: | Returns the exponent bits of the single-precision floating-point value `a'.
667: *----------------------------------------------------------------------------*/
668:
669: static inline int extractFloat32Exp(float32 a)
670: {
671:
672: return ( float32_val(a)>>23 ) & 0xFF;
673:
674: }
675:
676: /*----------------------------------------------------------------------------
677: | Returns the sign bit of the single-precision floating-point value `a'.
678: *----------------------------------------------------------------------------*/
679:
680: static inline flag extractFloat32Sign( float32 a )
681: {
682:
683: return float32_val(a)>>31;
684:
685: }
686:
687: /*----------------------------------------------------------------------------
688: | Normalizes the subnormal single-precision floating-point value represented
689: | by the denormalized significand `aSig'. The normalized exponent and
690: | significand are stored at the locations pointed to by `zExpPtr' and
691: | `zSigPtr', respectively.
692: *----------------------------------------------------------------------------*/
693:
694: static void
695: normalizeFloat32Subnormal(uint32_t aSig, int *zExpPtr, uint32_t *zSigPtr)
696: {
697: int8_t shiftCount;
698:
699: shiftCount = countLeadingZeros32( aSig ) - 8;
700: *zSigPtr = aSig<<shiftCount;
701: *zExpPtr = 1 - shiftCount;
702:
703: }
704:
705: /*----------------------------------------------------------------------------
706: | Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
707: | single-precision floating-point value, returning the result. After being
708: | shifted into the proper positions, the three fields are simply added
709: | together to form the result. This means that any integer portion of `zSig'
710: | will be added into the exponent. Since a properly normalized significand
711: | will have an integer portion equal to 1, the `zExp' input should be 1 less
712: | than the desired result exponent whenever `zSig' is a complete, normalized
713: | significand.
714: *----------------------------------------------------------------------------*/
715:
716: static inline float32 packFloat32(flag zSign, int zExp, uint32_t zSig)
717: {
718:
719: return make_float32(
720: ( ( (uint32_t) zSign )<<31 ) + ( ( (uint32_t) zExp )<<23 ) + zSig);
721:
722: }
723:
724: /*----------------------------------------------------------------------------
725: | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
726: | and significand `zSig', and returns the proper single-precision floating-
727: | point value corresponding to the abstract input. Ordinarily, the abstract
728: | value is simply rounded and packed into the single-precision format, with
729: | the inexact exception raised if the abstract input cannot be represented
730: | exactly. However, if the abstract value is too large, the overflow and
731: | inexact exceptions are raised and an infinity or maximal finite value is
732: | returned. If the abstract value is too small, the input value is rounded to
733: | a subnormal number, and the underflow and inexact exceptions are raised if
734: | the abstract input cannot be represented exactly as a subnormal single-
735: | precision floating-point number.
736: | The input significand `zSig' has its binary point between bits 30
737: | and 29, which is 7 bits to the left of the usual location. This shifted
738: | significand must be normalized or smaller. If `zSig' is not normalized,
739: | `zExp' must be 0; in that case, the result returned is a subnormal number,
740: | and it must not require rounding. In the usual case that `zSig' is
741: | normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.
742: | The handling of underflow and overflow follows the IEC/IEEE Standard for
743: | Binary Floating-Point Arithmetic.
744: *----------------------------------------------------------------------------*/
745:
746: static float32 roundAndPackFloat32(flag zSign, int zExp, uint32_t zSig,
747: float_status *status)
748: {
749: int8_t roundingMode;
750: flag roundNearestEven;
751: int8_t roundIncrement, roundBits;
752: flag isTiny;
753:
754: roundingMode = status->float_rounding_mode;
755: roundNearestEven = ( roundingMode == float_round_nearest_even );
756: switch (roundingMode) {
757: case float_round_nearest_even:
758: case float_round_ties_away:
759: roundIncrement = 0x40;
760: break;
761: case float_round_to_zero:
762: roundIncrement = 0;
763: break;
764: case float_round_up:
765: roundIncrement = zSign ? 0 : 0x7f;
766: break;
767: case float_round_down:
768: roundIncrement = zSign ? 0x7f : 0;
769: break;
770: default:
771: abort();
772: break;
773: }
774: roundBits = zSig & 0x7F;
775: if ( 0xFD <= (uint16_t) zExp ) {
776: if ( ( 0xFD < zExp )
777: || ( ( zExp == 0xFD )
778: && ( (int32_t) ( zSig + roundIncrement ) < 0 ) )
779: ) {
780: #ifdef SOFTFLOAT_68K
781: float_raise( float_flag_overflow, status );
782: saveFloat32Internal( zSign, zExp, zSig, status );
783: if ( roundBits ) float_raise( float_flag_inexact, status );
784: #else
785: float_raise(float_flag_overflow | float_flag_inexact, status);
786: #endif
787: return packFloat32( zSign, 0xFF, - ( roundIncrement == 0 ));
788: }
789: if ( zExp < 0 ) {
790: if (status->flush_to_zero) {
791: //float_raise(float_flag_output_denormal, status);
792: return packFloat32(zSign, 0, 0);
793: }
794: isTiny =
795: (status->float_detect_tininess
796: == float_tininess_before_rounding)
797: || ( zExp < -1 )
798: || ( zSig + roundIncrement < 0x80000000 );
799: #ifdef SOFTFLOAT_68K
800: if ( isTiny ) {
801: float_raise( float_flag_underflow, status );
802: saveFloat32Internal( zSign, zExp, zSig, status );
803: }
804: #endif
805: shift32RightJamming( zSig, - zExp, &zSig );
806: zExp = 0;
807: roundBits = zSig & 0x7F;
808: #ifndef SOFTFLOAT_68K
809: if (isTiny && roundBits)
810: float_raise(float_flag_underflow, status);
811: #endif
812: }
813: }
814: if (roundBits) {
815: status->float_exception_flags |= float_flag_inexact;
816: }
817: zSig = ( zSig + roundIncrement )>>7;
818: zSig &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
819: if ( zSig == 0 ) zExp = 0;
820: return packFloat32( zSign, zExp, zSig );
821:
822: }
823:
824: /*----------------------------------------------------------------------------
825: | Returns the fraction bits of the double-precision floating-point value `a'.
826: *----------------------------------------------------------------------------*/
827:
828: static inline uint64_t extractFloat64Frac( float64 a )
829: {
830:
831: return float64_val(a) & LIT64( 0x000FFFFFFFFFFFFF );
832:
833: }
834:
835: /*----------------------------------------------------------------------------
836: | Returns the exponent bits of the double-precision floating-point value `a'.
837: *----------------------------------------------------------------------------*/
838:
839: static inline int extractFloat64Exp(float64 a)
840: {
841:
842: return ( float64_val(a)>>52 ) & 0x7FF;
843:
844: }
845:
846: /*----------------------------------------------------------------------------
847: | Returns the sign bit of the double-precision floating-point value `a'.
848: *----------------------------------------------------------------------------*/
849:
850: static inline flag extractFloat64Sign( float64 a )
851: {
852:
853: return float64_val(a)>>63;
854:
855: }
856:
857: /*----------------------------------------------------------------------------
858: | If `a' is denormal and we are in flush-to-zero mode then set the
859: | input-denormal exception and return zero. Otherwise just return the value.
860: *----------------------------------------------------------------------------*/
861: float64 float64_squash_input_denormal(float64 a, float_status *status)
862: {
863: if (status->flush_inputs_to_zero) {
864: if (extractFloat64Exp(a) == 0 && extractFloat64Frac(a) != 0) {
865: //float_raise(float_flag_input_denormal, status);
866: return make_float64(float64_val(a) & (1ULL << 63));
867: }
868: }
869: return a;
870: }
871:
872: /*----------------------------------------------------------------------------
873: | Normalizes the subnormal double-precision floating-point value represented
874: | by the denormalized significand `aSig'. The normalized exponent and
875: | significand are stored at the locations pointed to by `zExpPtr' and
876: | `zSigPtr', respectively.
877: *----------------------------------------------------------------------------*/
878:
879: static void
880: normalizeFloat64Subnormal(uint64_t aSig, int *zExpPtr, uint64_t *zSigPtr)
881: {
882: int8_t shiftCount;
883:
884: shiftCount = countLeadingZeros64( aSig ) - 11;
885: *zSigPtr = aSig<<shiftCount;
886: *zExpPtr = 1 - shiftCount;
887:
888: }
889:
890: /*----------------------------------------------------------------------------
891: | Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
892: | double-precision floating-point value, returning the result. After being
893: | shifted into the proper positions, the three fields are simply added
894: | together to form the result. This means that any integer portion of `zSig'
895: | will be added into the exponent. Since a properly normalized significand
896: | will have an integer portion equal to 1, the `zExp' input should be 1 less
897: | than the desired result exponent whenever `zSig' is a complete, normalized
898: | significand.
899: *----------------------------------------------------------------------------*/
900:
901: static inline float64 packFloat64(flag zSign, int zExp, uint64_t zSig)
902: {
903:
904: return make_float64(
905: ( ( (uint64_t) zSign )<<63 ) + ( ( (uint64_t) zExp )<<52 ) + zSig);
906:
907: }
908:
909: /*----------------------------------------------------------------------------
910: | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
911: | and significand `zSig', and returns the proper double-precision floating-
912: | point value corresponding to the abstract input. Ordinarily, the abstract
913: | value is simply rounded and packed into the double-precision format, with
914: | the inexact exception raised if the abstract input cannot be represented
915: | exactly. However, if the abstract value is too large, the overflow and
916: | inexact exceptions are raised and an infinity or maximal finite value is
917: | returned. If the abstract value is too small, the input value is rounded to
918: | a subnormal number, and the underflow and inexact exceptions are raised if
919: | the abstract input cannot be represented exactly as a subnormal double-
920: | precision floating-point number.
921: | The input significand `zSig' has its binary point between bits 62
922: | and 61, which is 10 bits to the left of the usual location. This shifted
923: | significand must be normalized or smaller. If `zSig' is not normalized,
924: | `zExp' must be 0; in that case, the result returned is a subnormal number,
925: | and it must not require rounding. In the usual case that `zSig' is
926: | normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.
927: | The handling of underflow and overflow follows the IEC/IEEE Standard for
928: | Binary Floating-Point Arithmetic.
929: *----------------------------------------------------------------------------*/
930:
931: static float64 roundAndPackFloat64(flag zSign, int zExp, uint64_t zSig,
932: float_status *status)
933: {
934: int8_t roundingMode;
935: flag roundNearestEven;
936: int roundIncrement, roundBits;
937: flag isTiny;
938:
939: roundingMode = status->float_rounding_mode;
940: roundNearestEven = ( roundingMode == float_round_nearest_even );
941: switch (roundingMode) {
942: case float_round_nearest_even:
943: case float_round_ties_away:
944: roundIncrement = 0x200;
945: break;
946: case float_round_to_zero:
947: roundIncrement = 0;
948: break;
949: case float_round_up:
950: roundIncrement = zSign ? 0 : 0x3ff;
951: break;
952: case float_round_down:
953: roundIncrement = zSign ? 0x3ff : 0;
954: break;
955: default:
956: abort();
957: }
958: roundBits = zSig & 0x3FF;
959: if ( 0x7FD <= (uint16_t) zExp ) {
960: if ( ( 0x7FD < zExp )
961: || ( ( zExp == 0x7FD )
962: && ( (int64_t) ( zSig + roundIncrement ) < 0 ) )
963: ) {
964: #ifdef SOFTFLOAT_68K
965: float_raise( float_flag_overflow, status );
966: saveFloat64Internal( zSign, zExp, zSig, status );
967: if ( roundBits ) float_raise( float_flag_inexact, status );
968: #else
969: float_raise(float_flag_overflow | float_flag_inexact, status);
970: #endif
971: return packFloat64( zSign, 0x7FF, - ( roundIncrement == 0 ));
972: }
973: if ( zExp < 0 ) {
974: if (status->flush_to_zero) {
975: //float_raise(float_flag_output_denormal, status);
976: return packFloat64(zSign, 0, 0);
977: }
978: isTiny =
979: (status->float_detect_tininess
980: == float_tininess_before_rounding)
981: || ( zExp < -1 )
982: || ( zSig + roundIncrement < LIT64( 0x8000000000000000 ) );
983: #ifdef SOFTFLOAT_68K
984: if ( isTiny ) {
985: float_raise( float_flag_underflow, status );
986: saveFloat64Internal( zSign, zExp, zSig, status );
987: }
988: #endif
989: shift64RightJamming( zSig, - zExp, &zSig );
990: zExp = 0;
991: roundBits = zSig & 0x3FF;
992: #ifndef SOFTFLOAT_68K
993: if (isTiny && roundBits)
994: float_raise(float_flag_underflow, status);
995: #endif
996: }
997: }
998: if (roundBits) {
999: status->float_exception_flags |= float_flag_inexact;
1000: }
1001: zSig = ( zSig + roundIncrement )>>10;
1002: zSig &= ~ ( ( ( roundBits ^ 0x200 ) == 0 ) & roundNearestEven );
1003: if ( zSig == 0 ) zExp = 0;
1004: return packFloat64( zSign, zExp, zSig );
1005:
1006: }
1007:
1008: /*----------------------------------------------------------------------------
1009: | Returns the fraction bits of the extended double-precision floating-point
1010: | value `a'.
1011: *----------------------------------------------------------------------------*/
1012:
1013: uint64_t extractFloatx80Frac( floatx80 a )
1014: {
1015:
1016: return a.low;
1017:
1018: }
1019:
1020: /*----------------------------------------------------------------------------
1021: | Returns the exponent bits of the extended double-precision floating-point
1022: | value `a'.
1023: *----------------------------------------------------------------------------*/
1024:
1025: int32_t extractFloatx80Exp( floatx80 a )
1026: {
1027:
1028: return a.high & 0x7FFF;
1029:
1030: }
1031:
1032: /*----------------------------------------------------------------------------
1033: | Returns the sign bit of the extended double-precision floating-point value
1034: | `a'.
1035: *----------------------------------------------------------------------------*/
1036:
1037: flag extractFloatx80Sign( floatx80 a )
1038: {
1039:
1040: return a.high>>15;
1041:
1042: }
1043:
1044: /*----------------------------------------------------------------------------
1045: | Normalizes the subnormal extended double-precision floating-point value
1046: | represented by the denormalized significand `aSig'. The normalized exponent
1047: | and significand are stored at the locations pointed to by `zExpPtr' and
1048: | `zSigPtr', respectively.
1049: *----------------------------------------------------------------------------*/
1050:
1051: void normalizeFloatx80Subnormal( uint64_t aSig, int32_t *zExpPtr, uint64_t *zSigPtr )
1052: {
1053: int8_t shiftCount;
1054:
1055: shiftCount = countLeadingZeros64( aSig );
1056: *zSigPtr = aSig<<shiftCount;
1057: #ifdef SOFTFLOAT_68K
1058: *zExpPtr = -shiftCount;
1059: #else
1060: *zExpPtr = 1 - shiftCount;
1061: #endif
1062: }
1063:
1064: /*----------------------------------------------------------------------------
1065: | Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
1066: | extended double-precision floating-point value, returning the result.
1067: *----------------------------------------------------------------------------*/
1068:
1069: floatx80 packFloatx80( flag zSign, int32_t zExp, uint64_t zSig )
1070: {
1071: floatx80 z;
1072:
1073: z.low = zSig;
1074: z.high = ( ( (uint16_t) zSign )<<15 ) + zExp;
1075: return z;
1076:
1077: }
1078:
1079: /*----------------------------------------------------------------------------
1080: | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
1081: | and extended significand formed by the concatenation of `zSig0' and `zSig1',
1082: | and returns the proper extended double-precision floating-point value
1083: | corresponding to the abstract input. Ordinarily, the abstract value is
1084: | rounded and packed into the extended double-precision format, with the
1085: | inexact exception raised if the abstract input cannot be represented
1086: | exactly. However, if the abstract value is too large, the overflow and
1087: | inexact exceptions are raised and an infinity or maximal finite value is
1088: | returned. If the abstract value is too small, the input value is rounded to
1089: | a subnormal number, and the underflow and inexact exceptions are raised if
1090: | the abstract input cannot be represented exactly as a subnormal extended
1091: | double-precision floating-point number.
1092: | If `roundingPrecision' is 32 or 64, the result is rounded to the same
1093: | number of bits as single or double precision, respectively. Otherwise, the
1094: | result is rounded to the full precision of the extended double-precision
1095: | format.
1096: | The input significand must be normalized or smaller. If the input
1097: | significand is not normalized, `zExp' must be 0; in that case, the result
1098: | returned is a subnormal number, and it must not require rounding. The
1099: | handling of underflow and overflow follows the IEC/IEEE Standard for Binary
1100: | Floating-Point Arithmetic.
1101: *----------------------------------------------------------------------------*/
1102:
1103: #ifndef SOFTFLOAT_68K
1104: floatx80 roundAndPackFloatx80(int8_t roundingPrecision, flag zSign,
1105: int32_t zExp, uint64_t zSig0, uint64_t zSig1,
1106: float_status *status)
1107: {
1108: int8_t roundingMode;
1109: flag roundNearestEven, increment, isTiny;
1110: int64_t roundIncrement, roundMask, roundBits;
1111:
1112: roundingMode = status->float_rounding_mode;
1113: roundNearestEven = ( roundingMode == float_round_nearest_even );
1114: if ( roundingPrecision == 80 ) goto precision80;
1115: if ( roundingPrecision == 64 ) {
1116: roundIncrement = LIT64( 0x0000000000000400 );
1117: roundMask = LIT64( 0x00000000000007FF );
1118: }
1119: else if ( roundingPrecision == 32 ) {
1120: roundIncrement = LIT64( 0x0000008000000000 );
1121: roundMask = LIT64( 0x000000FFFFFFFFFF );
1122: }
1123: else {
1124: goto precision80;
1125: }
1126: zSig0 |= ( zSig1 != 0 );
1127: switch (roundingMode) {
1128: case float_round_nearest_even:
1129: case float_round_ties_away:
1130: break;
1131: case float_round_to_zero:
1132: roundIncrement = 0;
1133: break;
1134: case float_round_up:
1135: roundIncrement = zSign ? 0 : roundMask;
1136: break;
1137: case float_round_down:
1138: roundIncrement = zSign ? roundMask : 0;
1139: break;
1140: default:
1141: abort();
1142: }
1143: roundBits = zSig0 & roundMask;
1144: #ifdef SOFTFLOAT_68K
1145: if ( 0x7FFE <= (uint32_t) zExp ) {
1146: #else
1147: if ( 0x7FFD <= (uint32_t) ( zExp - 1 ) ) {
1148: #endif
1149: if ( ( 0x7FFE < zExp )
1150: || ( ( zExp == 0x7FFE ) && ( zSig0 + roundIncrement < zSig0 ) )
1151: ) {
1152: goto overflow;
1153: }
1154: #ifdef SOFTFLOAT_68K
1155: if ( zExp < 0 ) {
1156: #else
1157: if ( zExp <= 0 ) {
1158: #endif
1159: if (status->flush_to_zero) {
1160: //float_raise(float_flag_output_denormal, status);
1161: return packFloatx80(zSign, 0, 0);
1162: }
1163: isTiny =
1164: (status->float_detect_tininess
1165: == float_tininess_before_rounding)
1166: #ifdef SOFTFLOAT_68K
1167: || ( zExp < -1 )
1168: #else
1169: || ( zExp < 0 )
1170: #endif
1171: || ( zSig0 <= zSig0 + roundIncrement );
1172: #ifdef SOFTFLOAT_68K
1173: if ( isTiny ) {
1174: float_raise( float_flag_underflow, status );
1175: saveFloatx80Internal( zSign, zExp, zSig0, zSig1, status );
1176: }
1177: shift64RightJamming( zSig0, -zExp, &zSig0 );
1178: #else
1179: shift64RightJamming( zSig0, 1 - zExp, &zSig0 );
1180: #endif
1181: zExp = 0;
1182: roundBits = zSig0 & roundMask;
1183: #ifdef SOFTFLOAT_68K
1184: if ( isTiny ) float_raise( float_flag_underflow, status );
1185: #else
1186: if (isTiny && roundBits) {
1187: float_raise(float_flag_underflow, status);
1188: }
1189: #endif
1190: if (roundBits) {
1191: status->float_exception_flags |= float_flag_inexact;
1192: }
1193: zSig0 += roundIncrement;
1194: #ifndef SOFTFLOAT_68K
1195: if ( (int64_t) zSig0 < 0 ) zExp = 1;
1196: #endif
1197: roundIncrement = roundMask + 1;
1198: if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {
1199: roundMask |= roundIncrement;
1200: }
1201: zSig0 &= ~ roundMask;
1202: return packFloatx80( zSign, zExp, zSig0 );
1203: }
1204: }
1205: if (roundBits) {
1206: status->float_exception_flags |= float_flag_inexact;
1207: }
1208: zSig0 += roundIncrement;
1209: if ( zSig0 < roundIncrement ) {
1210: ++zExp;
1211: zSig0 = LIT64( 0x8000000000000000 );
1212: }
1213: roundIncrement = roundMask + 1;
1214: if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {
1215: roundMask |= roundIncrement;
1216: }
1217: zSig0 &= ~ roundMask;
1218: if ( zSig0 == 0 ) zExp = 0;
1219: return packFloatx80( zSign, zExp, zSig0 );
1220: precision80:
1221: switch (roundingMode) {
1222: case float_round_nearest_even:
1223: case float_round_ties_away:
1224: increment = ((int64_t)zSig1 < 0);
1225: break;
1226: case float_round_to_zero:
1227: increment = 0;
1228: break;
1229: case float_round_up:
1230: increment = !zSign && zSig1;
1231: break;
1232: case float_round_down:
1233: increment = zSign && zSig1;
1234: break;
1235: default:
1236: abort();
1237: }
1238: #ifdef SOFTFLOAT_68K
1239: if ( 0x7FFE <= (uint32_t) zExp ) {
1240: #else
1241: if ( 0x7FFD <= (uint32_t) ( zExp - 1 ) ) {
1242: #endif
1243: if ( ( 0x7FFE < zExp )
1244: || ( ( zExp == 0x7FFE )
1245: && ( zSig0 == LIT64( 0xFFFFFFFFFFFFFFFF ) )
1246: && increment
1247: )
1248: ) {
1249: roundMask = 0;
1250: overflow:
1251: #ifndef SOFTFLOAT_68K
1252: float_raise(float_flag_overflow | float_flag_inexact, status);
1253: #else
1254: float_raise( float_flag_overflow, status );
1255: saveFloatx80Internal( zSign, zExp, zSig0, zSig1, status );
1256: if ( ( zSig0 & roundMask ) || zSig1 ) float_raise( float_flag_inexact, status );
1257: #endif
1258: if ( ( roundingMode == float_round_to_zero )
1259: || ( zSign && ( roundingMode == float_round_up ) )
1260: || ( ! zSign && ( roundingMode == float_round_down ) )
1261: ) {
1262: return packFloatx80( zSign, 0x7FFE, ~ roundMask );
1263: }
1264: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
1265: }
1266: #ifdef SOFTFLOAT_68K
1267: if ( zExp < 0 ) {
1268: #else
1269: if ( zExp <= 0 ) {
1270: #endif
1271: isTiny =
1272: (status->float_detect_tininess
1273: == float_tininess_before_rounding)
1274: #ifdef SOFTFLOAT_68K
1275: || ( zExp < -1 )
1276: #else
1277: || ( zExp < 0 )
1278: #endif
1279: || ! increment
1280: || ( zSig0 < LIT64( 0xFFFFFFFFFFFFFFFF ) );
1281: #ifdef SOFTFLOAT_68K
1282: if ( isTiny ) {
1283: float_raise( float_flag_underflow, status );
1284: saveFloatx80Internal( zSign, zExp, zSig0, zSig1, status );
1285: }
1286: shift64ExtraRightJamming( zSig0, zSig1, -zExp, &zSig0, &zSig1 );
1287: #else
1288: shift64ExtraRightJamming( zSig0, zSig1, 1 - zExp, &zSig0, &zSig1 );
1289: #endif
1290: zExp = 0;
1291: #ifndef SOFTFLOAT_68K
1292: if ( isTiny && zSig1 ) float_raise( float_flag_underflow, status );
1293: #endif
1294: if (zSig1) float_raise(float_flag_inexact, status);
1295: switch (roundingMode) {
1296: case float_round_nearest_even:
1297: case float_round_ties_away:
1298: increment = ((int64_t)zSig1 < 0);
1299: break;
1300: case float_round_to_zero:
1301: increment = 0;
1302: break;
1303: case float_round_up:
1304: increment = !zSign && zSig1;
1305: break;
1306: case float_round_down:
1307: increment = zSign && zSig1;
1308: break;
1309: default:
1310: abort();
1311: }
1312: if ( increment ) {
1313: ++zSig0;
1314: zSig0 &=
1315: ~ ( ( (uint64_t) ( zSig1<<1 ) == 0 ) & roundNearestEven );
1316: #ifndef SOFTFLOAT_68K
1317: if ( (int64_t) zSig0 < 0 ) zExp = 1;
1318: #endif
1319: }
1320: return packFloatx80( zSign, zExp, zSig0 );
1321: }
1322: }
1323: if (zSig1) {
1324: status->float_exception_flags |= float_flag_inexact;
1325: }
1326: if ( increment ) {
1327: ++zSig0;
1328: if ( zSig0 == 0 ) {
1329: ++zExp;
1330: zSig0 = LIT64( 0x8000000000000000 );
1331: }
1332: else {
1333: zSig0 &= ~ ( ( (uint64_t) ( zSig1<<1 ) == 0 ) & roundNearestEven );
1334: }
1335: }
1336: else {
1337: if ( zSig0 == 0 ) zExp = 0;
1338: }
1339: return packFloatx80( zSign, zExp, zSig0 );
1340:
1341: }
1342:
1343: #else // SOFTFLOAT_68K
1344:
1345: floatx80 roundAndPackFloatx80( int8_t roundingPrecision, flag zSign, int32_t zExp, uint64_t zSig0, uint64_t zSig1, float_status *status )
1346: {
1347: int8_t roundingMode;
1348: flag roundNearestEven, increment;
1349: int64_t roundIncrement, roundMask, roundBits;
1350: int32_t expOffset;
1351:
1352: roundingMode = status->float_rounding_mode;
1353: roundNearestEven = ( roundingMode == float_round_nearest_even );
1354: if ( roundingPrecision == 80 ) goto precision80;
1355: if ( roundingPrecision == 64 ) {
1356: roundIncrement = LIT64( 0x0000000000000400 );
1357: roundMask = LIT64( 0x00000000000007FF );
1358: expOffset = 0x3C00;
1359: } else if ( roundingPrecision == 32 ) {
1360: roundIncrement = LIT64( 0x0000008000000000 );
1361: roundMask = LIT64( 0x000000FFFFFFFFFF );
1362: expOffset = 0x3F80;
1363: } else {
1364: goto precision80;
1365: }
1366: zSig0 |= ( zSig1 != 0 );
1367: if ( ! roundNearestEven ) {
1368: if ( roundingMode == float_round_to_zero ) {
1369: roundIncrement = 0;
1370: } else {
1371: roundIncrement = roundMask;
1372: if ( zSign ) {
1373: if ( roundingMode == float_round_up ) roundIncrement = 0;
1374: } else {
1375: if ( roundingMode == float_round_down ) roundIncrement = 0;
1376: }
1377: }
1378: }
1379: roundBits = zSig0 & roundMask;
1380: if ( ( ( 0x7FFE - expOffset ) < zExp ) ||
1381: ( ( zExp == ( 0x7FFE - expOffset ) ) && ( zSig0 + roundIncrement < zSig0 ) ) ) {
1382: float_raise( float_flag_overflow, status );
1383: saveFloatx80Internal( roundingPrecision, zSign, zExp, zSig0, zSig1, status );
1384: if ( zSig0 & roundMask ) float_raise( float_flag_inexact, status );
1385: if ( ( roundingMode == float_round_to_zero )
1386: || ( zSign && ( roundingMode == float_round_up ) )
1387: || ( ! zSign && ( roundingMode == float_round_down ) )
1388: ) {
1389: return packFloatx80( zSign, 0x7FFE - expOffset, ~ roundMask );
1390: }
1391: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
1392: }
1393: if ( zExp < ( expOffset + 1 ) ) {
1394: float_raise( float_flag_underflow, status );
1395: saveFloatx80Internal( roundingPrecision, zSign, zExp, zSig0, zSig1, status );
1396: shift64RightJamming( zSig0, -( zExp - ( expOffset + 1 ) ), &zSig0 );
1397: zExp = expOffset + 1;
1398: roundBits = zSig0 & roundMask;
1399: if ( roundBits ) float_raise( float_flag_inexact, status );
1400: zSig0 += roundIncrement;
1401: roundIncrement = roundMask + 1;
1402: if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {
1403: roundMask |= roundIncrement;
1404: }
1405: zSig0 &= ~ roundMask;
1406: return packFloatx80( zSign, zExp, zSig0 );
1407: }
1408: if ( roundBits ) {
1409: float_raise( float_flag_inexact, status );
1410: saveFloatx80Internal( roundingPrecision, zSign, zExp, zSig0, zSig1, status);
1411: }
1412: zSig0 += roundIncrement;
1413: if ( zSig0 < roundIncrement ) {
1414: ++zExp;
1415: zSig0 = LIT64( 0x8000000000000000 );
1416: }
1417: roundIncrement = roundMask + 1;
1418: if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {
1419: roundMask |= roundIncrement;
1420: }
1421: zSig0 &= ~ roundMask;
1422: if ( zSig0 == 0 ) zExp = 0;
1423: return packFloatx80( zSign, zExp, zSig0 );
1424: precision80:
1425: increment = ( (int64_t) zSig1 < 0 );
1426: if ( ! roundNearestEven ) {
1427: if ( roundingMode == float_round_to_zero ) {
1428: increment = 0;
1429: } else {
1430: if ( zSign ) {
1431: increment = ( roundingMode == float_round_down ) && zSig1;
1432: } else {
1433: increment = ( roundingMode == float_round_up ) && zSig1;
1434: }
1435: }
1436: }
1437: if ( 0x7FFE <= (uint32_t) zExp ) {
1438: if ( ( 0x7FFE < zExp ) ||
1439: ( ( zExp == 0x7FFE ) && ( zSig0 == LIT64( 0xFFFFFFFFFFFFFFFF ) ) && increment )
1440: ) {
1441: roundMask = 0;
1442: float_raise( float_flag_overflow, status );
1443: saveFloatx80Internal( roundingPrecision, zSign, zExp, zSig0, zSig1, status );
1444: if ( ( zSig0 & roundMask ) || zSig1 ) float_raise( float_flag_inexact, status );
1445: if ( ( roundingMode == float_round_to_zero )
1446: || ( zSign && ( roundingMode == float_round_up ) )
1447: || ( ! zSign && ( roundingMode == float_round_down ) )
1448: ) {
1449: return packFloatx80( zSign, 0x7FFE, ~ roundMask );
1450: }
1451: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
1452: }
1453: if ( zExp < 0 ) {
1454: float_raise( float_flag_underflow, status );
1455: saveFloatx80Internal( roundingPrecision, zSign, zExp, zSig0, zSig1, status);
1456: shift64ExtraRightJamming( zSig0, zSig1, -zExp, &zSig0, &zSig1 );
1457: zExp = 0;
1458: if ( zSig1 ) float_raise( float_flag_inexact, status );
1459: if ( roundNearestEven ) {
1460: increment = ( (int64_t) zSig1 < 0 );
1461: } else {
1462: if ( zSign ) {
1463: increment = ( roundingMode == float_round_down ) && zSig1;
1464: } else {
1465: increment = ( roundingMode == float_round_up ) && zSig1;
1466: }
1467: }
1468: if ( increment ) {
1469: ++zSig0;
1470: zSig0 &=
1471: ~ ( ( (uint64_t) ( zSig1<<1 ) == 0 ) & roundNearestEven );
1472: }
1473: return packFloatx80( zSign, zExp, zSig0 );
1474: }
1475: }
1476: if ( zSig1 ) {
1477: float_raise( float_flag_inexact, status );
1478: saveFloatx80Internal( roundingPrecision, zSign, zExp, zSig0, zSig1, status );
1479: }
1480: if ( increment ) {
1481: ++zSig0;
1482: if ( zSig0 == 0 ) {
1483: ++zExp;
1484: zSig0 = LIT64( 0x8000000000000000 );
1485: } else {
1486: zSig0 &= ~ ( ( (uint64_t) ( zSig1<<1 ) == 0 ) & roundNearestEven );
1487: }
1488: } else {
1489: if ( zSig0 == 0 ) zExp = 0;
1490: }
1491: return packFloatx80( zSign, zExp, zSig0 );
1492:
1493: }
1494:
1495: #endif
1496:
1497: #ifdef SOFTFLOAT_68K // 21-01-2017: Added for Previous
1498: floatx80 roundSigAndPackFloatx80( int8_t roundingPrecision, flag zSign, int32_t zExp, uint64_t zSig0, uint64_t zSig1, float_status *status )
1499: {
1500: int8_t roundingMode;
1501: flag roundNearestEven, isTiny;
1502: int64_t roundIncrement, roundMask, roundBits;
1503:
1504: roundingMode = status->float_rounding_mode;
1505: roundNearestEven = ( roundingMode == float_round_nearest_even );
1506: if ( roundingPrecision == 32 ) {
1507: roundIncrement = LIT64( 0x0000008000000000 );
1508: roundMask = LIT64( 0x000000FFFFFFFFFF );
1509: } else if ( roundingPrecision == 64 ) {
1510: roundIncrement = LIT64( 0x0000000000000400 );
1511: roundMask = LIT64( 0x00000000000007FF );
1512: } else {
1513: return roundAndPackFloatx80( 80, zSign, zExp, zSig0, zSig1, status );
1514: }
1515: zSig0 |= ( zSig1 != 0 );
1516: if ( ! roundNearestEven ) {
1517: if ( roundingMode == float_round_to_zero ) {
1518: roundIncrement = 0;
1519: }
1520: else {
1521: roundIncrement = roundMask;
1522: if ( zSign ) {
1523: if ( roundingMode == float_round_up ) roundIncrement = 0;
1524: }
1525: else {
1526: if ( roundingMode == float_round_down ) roundIncrement = 0;
1527: }
1528: }
1529: }
1530: roundBits = zSig0 & roundMask;
1531:
1532: if ( 0x7FFE <= (uint32_t) zExp ) {
1533: if ( ( 0x7FFE < zExp )
1534: || ( ( zExp == 0x7FFE ) && ( zSig0 + roundIncrement < zSig0 ) )
1535: ) {
1536: float_raise( float_flag_overflow, status );
1537: saveFloatx80Internal( roundingPrecision, zSign, zExp, zSig0, zSig1, status);
1538: if ( zSig0 & roundMask ) float_raise( float_flag_inexact, status );
1539: if ( ( roundingMode == float_round_to_zero )
1540: || ( zSign && ( roundingMode == float_round_up ) )
1541: || ( ! zSign && ( roundingMode == float_round_down ) )
1542: ) {
1543: return packFloatx80( zSign, 0x7FFE, LIT64( 0xFFFFFFFFFFFFFFFF ) );
1544: }
1545: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
1546: }
1547:
1548: if ( zExp < 0 ) {
1549: isTiny =
1550: ( status->float_detect_tininess == float_tininess_before_rounding )
1551: || ( zExp < -1 )
1552: || ( zSig0 <= zSig0 + roundIncrement );
1553: if ( isTiny ) {
1554: float_raise( float_flag_underflow, status );
1555: saveFloatx80Internal( roundingPrecision, zSign, zExp, zSig0, zSig1, status );
1556: }
1557: shift64RightJamming( zSig0, -zExp, &zSig0 );
1558: zExp = 0;
1559: roundBits = zSig0 & roundMask;
1560: if ( roundBits ) float_raise ( float_flag_inexact, status );
1561: zSig0 += roundIncrement;
1562: if ( roundNearestEven && ( roundBits == roundIncrement ) ) {
1563: roundMask |= roundIncrement<<1;
1564: }
1565: zSig0 &= ~roundMask;
1566: return packFloatx80( zSign, zExp, zSig0 );
1567: }
1568: }
1569: if ( roundBits ) {
1570: float_raise( float_flag_inexact, status );
1571: saveFloatx80Internal( roundingPrecision, zSign, zExp, zSig0, zSig1, status );
1572: }
1573: zSig0 += roundIncrement;
1574: if ( zSig0 < roundIncrement ) {
1575: ++zExp;
1576: zSig0 = LIT64( 0x8000000000000000 );
1577: }
1578: roundIncrement = roundMask + 1;
1579: if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {
1580: roundMask |= roundIncrement;
1581: }
1582: zSig0 &= ~ roundMask;
1583: if ( zSig0 == 0 ) zExp = 0;
1584: return packFloatx80( zSign, zExp, zSig0 );
1585:
1586: }
1587: #endif // End of Addition for Previous
1588:
1589:
1590: /*----------------------------------------------------------------------------
1591: | Takes an abstract floating-point value having sign `zSign', exponent
1592: | `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',
1593: | and returns the proper extended double-precision floating-point value
1594: | corresponding to the abstract input. This routine is just like
1595: | `roundAndPackFloatx80' except that the input significand does not have to be
1596: | normalized.
1597: *----------------------------------------------------------------------------*/
1598:
1599: static floatx80 normalizeRoundAndPackFloatx80(int8_t roundingPrecision,
1600: flag zSign, int32_t zExp,
1601: uint64_t zSig0, uint64_t zSig1,
1602: float_status *status)
1603: {
1604: int8_t shiftCount;
1605:
1606: if ( zSig0 == 0 ) {
1607: zSig0 = zSig1;
1608: zSig1 = 0;
1609: zExp -= 64;
1610: }
1611: shiftCount = countLeadingZeros64( zSig0 );
1612: shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );
1613: zExp -= shiftCount;
1614: return roundAndPackFloatx80(roundingPrecision, zSign, zExp,
1615: zSig0, zSig1, status);
1616:
1617: }
1618:
1619: /*----------------------------------------------------------------------------
1620: | Returns the result of converting the 32-bit two's complement integer `a'
1621: | to the extended double-precision floating-point format. The conversion
1622: | is performed according to the IEC/IEEE Standard for Binary Floating-Point
1623: | Arithmetic.
1624: *----------------------------------------------------------------------------*/
1625:
1626: floatx80 int32_to_floatx80(int32_t a)
1627: {
1628: flag zSign;
1629: uint32_t absA;
1630: int8_t shiftCount;
1631: uint64_t zSig;
1632:
1633: if ( a == 0 ) return packFloatx80( 0, 0, 0 );
1634: zSign = ( a < 0 );
1635: absA = zSign ? - a : a;
1636: shiftCount = countLeadingZeros32( absA ) + 32;
1637: zSig = absA;
1638: return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );
1639:
1640: }
1641:
1642: /*----------------------------------------------------------------------------
1643: | Returns the result of converting the single-precision floating-point value
1644: | `a' to the extended double-precision floating-point format. The conversion
1645: | is performed according to the IEC/IEEE Standard for Binary Floating-Point
1646: | Arithmetic.
1647: *----------------------------------------------------------------------------*/
1648:
1649: floatx80 float32_to_floatx80(float32 a, float_status *status)
1650: {
1651: flag aSign;
1652: int aExp;
1653: uint32_t aSig;
1654:
1655: aSig = extractFloat32Frac( a );
1656: aExp = extractFloat32Exp( a );
1657: aSign = extractFloat32Sign( a );
1658: if ( aExp == 0xFF ) {
1659: if ( aSig ) return commonNaNToFloatx80( float32ToCommonNaN( a, status ), status );
1660: return packFloatx80( aSign, 0x7FFF, floatx80_default_infinity_low );
1661: }
1662: if ( aExp == 0 ) {
1663: if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1664: normalizeFloat32Subnormal( aSig, &aExp, &aSig );
1665: }
1666: aSig |= 0x00800000;
1667: return packFloatx80( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<40 );
1668:
1669: }
1670:
1671: #ifdef SOFTFLOAT_68K // 31-12-2016: Added for Previous
1672: floatx80 float32_to_floatx80_allowunnormal(float32 a , float_status *status)
1673: {
1674: flag aSign;
1675: int16_t aExp;
1676: uint32_t aSig;
1677:
1678: aSig = extractFloat32Frac(a);
1679: aExp = extractFloat32Exp(a);
1680: aSign = extractFloat32Sign(a);
1681: if (aExp == 0xFF) {
1682: return packFloatx80( aSign, 0x7FFF, ( (uint64_t) aSig )<<40 );
1683: }
1684: if (aExp == 0) {
1685: if (aSig == 0) return packFloatx80(aSign, 0, 0);
1686: return packFloatx80(aSign, 0x3F81, ((uint64_t) aSig) << 40);
1687: }
1688: aSig |= 0x00800000;
1689: return packFloatx80(aSign, aExp + 0x3F80, ((uint64_t)aSig) << 40);
1690:
1691: }
1692: #endif // end of addition for Previous
1693:
1694: /*----------------------------------------------------------------------------
1695: | Returns the result of converting the double-precision floating-point value
1696: | `a' to the extended double-precision floating-point format. The conversion
1697: | is performed according to the IEC/IEEE Standard for Binary Floating-Point
1698: | Arithmetic.
1699: *----------------------------------------------------------------------------*/
1700:
1701: floatx80 float64_to_floatx80(float64 a, float_status *status)
1702: {
1703: flag aSign;
1704: int aExp;
1705: uint64_t aSig;
1706:
1707: aSig = extractFloat64Frac( a );
1708: aExp = extractFloat64Exp( a );
1709: aSign = extractFloat64Sign( a );
1710: if ( aExp == 0x7FF ) {
1711: if ( aSig ) return commonNaNToFloatx80( float64ToCommonNaN( a, status ), status );
1712: return packFloatx80( aSign, 0x7FFF, floatx80_default_infinity_low );
1713: }
1714: if ( aExp == 0 ) {
1715: if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1716: normalizeFloat64Subnormal( aSig, &aExp, &aSig );
1717: }
1718: return
1719: packFloatx80(
1720: aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
1721:
1722: }
1723:
1724: #ifdef SOFTFLOAT_68K // 31-12-2016: Added for Previous
1725: floatx80 float64_to_floatx80_allowunnormal( float64 a, float_status *status )
1726: {
1727: flag aSign;
1728: int16_t aExp;
1729: uint64_t aSig;
1730:
1731: aSig = extractFloat64Frac( a );
1732: aExp = extractFloat64Exp( a );
1733: aSign = extractFloat64Sign( a );
1734: if ( aExp == 0x7FF ) {
1735: return packFloatx80( aSign, 0x7FFF, aSig<<11 );
1736: }
1737: if ( aExp == 0 ) {
1738: if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1739: return packFloatx80( aSign, 0x3C01, aSig<<11 );
1740: }
1741: return
1742: packFloatx80(
1743: aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
1744:
1745: }
1746: #endif // end of addition for Previous
1747:
1748: /*----------------------------------------------------------------------------
1749: | Returns the result of converting the extended double-precision floating-
1750: | point value `a' to the 32-bit two's complement integer format. The
1751: | conversion is performed according to the IEC/IEEE Standard for Binary
1752: | Floating-Point Arithmetic---which means in particular that the conversion
1753: | is rounded according to the current rounding mode. If `a' is a NaN, the
1754: | largest positive integer is returned. Otherwise, if the conversion
1755: | overflows, the largest integer with the same sign as `a' is returned.
1756: *----------------------------------------------------------------------------*/
1757:
1758: int32_t floatx80_to_int32(floatx80 a, float_status *status)
1759: {
1760: flag aSign;
1761: int32_t aExp, shiftCount;
1762: uint64_t aSig;
1763:
1764: aSig = extractFloatx80Frac( a );
1765: aExp = extractFloatx80Exp( a );
1766: aSign = extractFloatx80Sign( a );
1767: #ifdef SOFTFLOAT_68K
1768: if ( aExp == 0x7FFF ) {
1769: if ( (uint64_t) ( aSig<<1 ) ) {
1770: a = propagateFloatx80NaNOneArg( a, status );
1771: if ( a.low == aSig ) float_raise( float_flag_invalid, status );
1772: return (int32_t)(a.low>>32);
1773: }
1774: float_raise( float_flag_invalid, status );
1775: return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
1776: }
1777: #else
1778: if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
1779: #endif
1780: shiftCount = 0x4037 - aExp;
1781: if ( shiftCount <= 0 ) shiftCount = 1;
1782: shift64RightJamming( aSig, shiftCount, &aSig );
1783: return roundAndPackInt32(aSign, aSig, status);
1784:
1785: }
1786:
1787: #ifdef SOFTFLOAT_68K // 30-01-2017: Addition for Previous
1788: int16_t floatx80_to_int16( floatx80 a, float_status *status)
1789: {
1790: flag aSign;
1791: int32_t aExp, shiftCount;
1792: uint64_t aSig;
1793:
1794: aSig = extractFloatx80Frac( a );
1795: aExp = extractFloatx80Exp( a );
1796: aSign = extractFloatx80Sign( a );
1797: if ( aExp == 0x7FFF ) {
1798: float_raise( float_flag_invalid, status );
1799: if ( (uint64_t) ( aSig<<1 ) ) {
1800: a = propagateFloatx80NaNOneArg( a, status );
1801: if ( a.low == aSig ) float_raise( float_flag_invalid, status );
1802: return (int16_t)(a.low>>48);
1803: }
1804: return aSign ? (int16_t) 0x8000 : 0x7FFF;
1805: }
1806: shiftCount = 0x4037 - aExp;
1807: if ( shiftCount <= 0 ) shiftCount = 1;
1808: shift64RightJamming( aSig, shiftCount, &aSig );
1809: return roundAndPackInt16( aSign, aSig, status );
1810:
1811: }
1812: int8_t floatx80_to_int8( floatx80 a, float_status *status)
1813: {
1814: flag aSign;
1815: int32_t aExp, shiftCount;
1816: uint64_t aSig;
1817:
1818: aSig = extractFloatx80Frac( a );
1819: aExp = extractFloatx80Exp( a );
1820: aSign = extractFloatx80Sign( a );
1821: if ( aExp == 0x7FFF ) {
1822: if ( (uint64_t) ( aSig<<1 ) ) {
1823: a = propagateFloatx80NaNOneArg( a, status );
1824: if ( a.low == aSig ) float_raise( float_flag_invalid, status );
1825: return (int8_t)(a.low>>56);
1826: }
1827: float_raise( float_flag_invalid, status );
1828: return aSign ? (int8_t) 0x80 : 0x7F;
1829: }
1830: shiftCount = 0x4037 - aExp;
1831: if ( shiftCount <= 0 ) shiftCount = 1;
1832: shift64RightJamming( aSig, shiftCount, &aSig );
1833: return roundAndPackInt8( aSign, aSig, status );
1834:
1835: }
1836: #endif // End of addition for Previous
1837:
1838:
1839: /*----------------------------------------------------------------------------
1840: | Returns the result of converting the extended double-precision floating-
1841: | point value `a' to the 32-bit two's complement integer format. The
1842: | conversion is performed according to the IEC/IEEE Standard for Binary
1843: | Floating-Point Arithmetic, except that the conversion is always rounded
1844: | toward zero. If `a' is a NaN, the largest positive integer is returned.
1845: | Otherwise, if the conversion overflows, the largest integer with the same
1846: | sign as `a' is returned.
1847: *----------------------------------------------------------------------------*/
1848:
1849: int32_t floatx80_to_int32_round_to_zero(floatx80 a, float_status *status)
1850: {
1851: flag aSign;
1852: int32_t aExp, shiftCount;
1853: uint64_t aSig, savedASig;
1854: int32_t z;
1855:
1856: if (floatx80_invalid_encoding(a)) {
1857: float_raise(float_flag_invalid, status);
1858: return 1 << 31;
1859: }
1860: aSig = extractFloatx80Frac( a );
1861: aExp = extractFloatx80Exp( a );
1862: aSign = extractFloatx80Sign( a );
1863: if ( 0x401E < aExp ) {
1864: if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
1865: goto invalid;
1866: }
1867: else if ( aExp < 0x3FFF ) {
1868: if (aExp || aSig) {
1869: status->float_exception_flags |= float_flag_inexact;
1870: }
1871: return 0;
1872: }
1873: shiftCount = 0x403E - aExp;
1874: savedASig = aSig;
1875: aSig >>= shiftCount;
1876: z = aSig;
1877: if ( aSign ) z = - z;
1878: if ( ( z < 0 ) ^ aSign ) {
1879: invalid:
1880: float_raise(float_flag_invalid, status);
1881: return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
1882: }
1883: if ( ( aSig<<shiftCount ) != savedASig ) {
1884: status->float_exception_flags |= float_flag_inexact;
1885: }
1886: return z;
1887:
1888: }
1889:
1890: /*----------------------------------------------------------------------------
1891: | Returns the result of converting the extended double-precision floating-
1892: | point value `a' to the 64-bit two's complement integer format. The
1893: | conversion is performed according to the IEC/IEEE Standard for Binary
1894: | Floating-Point Arithmetic---which means in particular that the conversion
1895: | is rounded according to the current rounding mode. If `a' is a NaN,
1896: | the largest positive integer is returned. Otherwise, if the conversion
1897: | overflows, the largest integer with the same sign as `a' is returned.
1898: *----------------------------------------------------------------------------*/
1899:
1900: int64_t floatx80_to_int64(floatx80 a, float_status *status)
1901: {
1902: flag aSign;
1903: int32_t aExp, shiftCount;
1904: uint64_t aSig, aSigExtra;
1905:
1906: if (floatx80_invalid_encoding(a)) {
1907: float_raise(float_flag_invalid, status);
1908: return 1ULL << 63;
1909: }
1910: aSig = extractFloatx80Frac( a );
1911: aExp = extractFloatx80Exp( a );
1912: aSign = extractFloatx80Sign( a );
1913: shiftCount = 0x403E - aExp;
1914: if ( shiftCount <= 0 ) {
1915: if ( shiftCount ) {
1916: float_raise(float_flag_invalid, status);
1917: if ( ! aSign
1918: || ( ( aExp == 0x7FFF )
1919: && ( aSig != LIT64( 0x8000000000000000 ) ) )
1920: ) {
1921: return LIT64( 0x7FFFFFFFFFFFFFFF );
1922: }
1923: return (int64_t) LIT64( 0x8000000000000000 );
1924: }
1925: aSigExtra = 0;
1926: }
1927: else {
1928: shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );
1929: }
1930: return roundAndPackInt64(aSign, aSig, aSigExtra, status);
1931:
1932: }
1933:
1934: /*----------------------------------------------------------------------------
1935: | Returns the result of converting the extended double-precision floating-
1936: | point value `a' to the single-precision floating-point format. The
1937: | conversion is performed according to the IEC/IEEE Standard for Binary
1938: | Floating-Point Arithmetic.
1939: *----------------------------------------------------------------------------*/
1940:
1941: float32 floatx80_to_float32(floatx80 a, float_status *status)
1942: {
1943: flag aSign;
1944: int32_t aExp;
1945: uint64_t aSig;
1946:
1947: aSig = extractFloatx80Frac( a );
1948: aExp = extractFloatx80Exp( a );
1949: aSign = extractFloatx80Sign( a );
1950: if ( aExp == 0x7FFF ) {
1951: if ( (uint64_t) ( aSig<<1 ) ) {
1952: return commonNaNToFloat32(floatx80ToCommonNaN(a, status));
1953: }
1954: return packFloat32( aSign, 0xFF, 0 );
1955: }
1956: #ifdef SOFTFLOAT_68K
1957: if ( aExp == 0 ) {
1958: if ( aSig == 0) return packFloat32( aSign, 0, 0 );
1959: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
1960: }
1961: shift64RightJamming( aSig, 33, &aSig );
1962: aExp -= 0x3F81;
1963: #else
1964: shift64RightJamming( aSig, 33, &aSig );
1965: if ( aExp || aSig ) aExp -= 0x3F81;
1966: #endif
1967: return roundAndPackFloat32(aSign, aExp, aSig, status);
1968:
1969: }
1970:
1971: /*----------------------------------------------------------------------------
1972: | Returns the result of converting the extended double-precision floating-
1973: | point value `a' to the double-precision floating-point format. The
1974: | conversion is performed according to the IEC/IEEE Standard for Binary
1975: | Floating-Point Arithmetic.
1976: *----------------------------------------------------------------------------*/
1977:
1978: float64 floatx80_to_float64(floatx80 a, float_status *status)
1979: {
1980: flag aSign;
1981: int32_t aExp;
1982: uint64_t aSig, zSig;
1983:
1984: aSig = extractFloatx80Frac( a );
1985: aExp = extractFloatx80Exp( a );
1986: aSign = extractFloatx80Sign( a );
1987: if ( aExp == 0x7FFF ) {
1988: if ( (uint64_t) ( aSig<<1 ) ) {
1989: return commonNaNToFloat64(floatx80ToCommonNaN(a, status), status);
1990: }
1991: return packFloat64( aSign, 0x7FF, 0 );
1992: }
1993: #ifdef SOFTFLOAT_68K
1994: if ( aExp == 0 ) {
1995: if ( aSig == 0) return packFloat64( aSign, 0, 0 );
1996: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
1997: }
1998: shift64RightJamming( aSig, 1, &zSig );
1999: aExp -= 0x3C01;
2000: #else
2001: shift64RightJamming( aSig, 1, &zSig );
2002: if ( aExp || aSig ) aExp -= 0x3C01;
2003: #endif
2004: return roundAndPackFloat64(aSign, aExp, zSig, status);
2005:
2006: }
2007:
2008: #ifdef SOFTFLOAT_68K // 31-01-2017
2009: /*----------------------------------------------------------------------------
2010: | Returns the result of converting the extended double-precision floating-
2011: | point value `a' to the extended double-precision floating-point format.
2012: | The conversion is performed according to the IEC/IEEE Standard for Binary
2013: | Floating-Point Arithmetic.
2014: *----------------------------------------------------------------------------*/
2015:
2016: floatx80 floatx80_to_floatx80( floatx80 a, float_status *status )
2017: {
2018: flag aSign;
2019: int32_t aExp;
2020: uint64_t aSig;
2021:
2022: aSig = extractFloatx80Frac( a );
2023: aExp = extractFloatx80Exp( a );
2024: aSign = extractFloatx80Sign( a );
2025:
2026: if ( aExp == 0x7FFF && (uint64_t) ( aSig<<1 ) ) {
2027: return propagateFloatx80NaNOneArg( a, status );
2028: }
2029: if ( aExp == 0 && aSig != 0 ) {
2030: return normalizeRoundAndPackFloatx80( status->floatx80_rounding_precision, aSign, aExp, aSig, 0, status );
2031: }
2032: return a;
2033:
2034: }
2035: #endif
2036:
2037: #ifdef SOFTFLOAT_68K // 30-01-2016: Added for Previous
2038: floatx80 floatx80_round32( floatx80 a, float_status *status )
2039: {
2040: flag aSign;
2041: int32_t aExp;
2042: uint64_t aSig;
2043:
2044: aSig = extractFloatx80Frac( a );
2045: aExp = extractFloatx80Exp( a );
2046: aSign = extractFloatx80Sign( a );
2047:
2048: if ( aExp == 0x7FFF || aSig == 0 ) {
2049: return a;
2050: }
2051: if ( aExp == 0 ) {
2052: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2053: }
2054:
2055: return roundSigAndPackFloatx80( 32, aSign, aExp, aSig, 0, status );
2056: }
2057:
2058: floatx80 floatx80_round64( floatx80 a, float_status *status )
2059: {
2060: flag aSign;
2061: int32_t aExp;
2062: uint64_t aSig;
2063:
2064: aSig = extractFloatx80Frac( a );
2065: aExp = extractFloatx80Exp( a );
2066: aSign = extractFloatx80Sign( a );
2067:
2068: if ( aExp == 0x7FFF || aSig == 0 ) {
2069: return a;
2070: }
2071: if ( aExp == 0 ) {
2072: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2073: }
2074:
2075: return roundSigAndPackFloatx80( 64, aSign, aExp, aSig, 0, status );
2076: }
2077:
2078: floatx80 floatx80_round_to_float32( floatx80 a, float_status *status )
2079: {
2080: flag aSign;
2081: int32_t aExp;
2082: uint64_t aSig;
2083:
2084: aSign = extractFloatx80Sign( a );
2085: aSig = extractFloatx80Frac( a );
2086: aExp = extractFloatx80Exp( a );
2087:
2088: if ( aExp == 0x7FFF ) {
2089: if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaNOneArg( a, status );
2090: return a;
2091: }
2092: if ( aExp == 0 ) {
2093: if ( aSig == 0 ) return a;
2094: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2095: }
2096:
2097: return roundAndPackFloatx80( 32, aSign, aExp, aSig, 0, status );
2098: }
2099:
2100: floatx80 floatx80_round_to_float64( floatx80 a, float_status *status )
2101: {
2102: flag aSign;
2103: int32_t aExp;
2104: uint64_t aSig;
2105:
2106: aSign = extractFloatx80Sign( a );
2107: aSig = extractFloatx80Frac( a );
2108: aExp = extractFloatx80Exp( a );
2109:
2110: if ( aExp == 0x7FFF ) {
2111: if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaNOneArg( a, status );
2112: return a;
2113: }
2114: if ( aExp == 0 ) {
2115: if ( aSig == 0 ) return a;
2116: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2117: }
2118:
2119: return roundAndPackFloatx80( 64, aSign, aExp, aSig, 0, status );
2120: }
2121:
2122:
2123: floatx80 floatx80_normalize( floatx80 a )
2124: {
2125: flag aSign;
2126: int16_t aExp;
2127: uint64_t aSig;
2128: int8_t shiftCount;
2129:
2130: aSig = extractFloatx80Frac( a );
2131: aExp = extractFloatx80Exp( a );
2132: aSign = extractFloatx80Sign( a );
2133:
2134: if ( aExp == 0x7FFF || aExp == 0 ) return a;
2135: if ( aSig == 0 ) return packFloatx80(aSign, 0, 0);
2136:
2137: shiftCount = countLeadingZeros64( aSig );
2138:
2139: if ( shiftCount > aExp ) shiftCount = aExp;
2140:
2141: aExp -= shiftCount;
2142: aSig <<= shiftCount;
2143:
2144: return packFloatx80( aSign, aExp, aSig );
2145: }
2146: #endif // end of addition for Previous
2147:
2148: /*----------------------------------------------------------------------------
2149: | Rounds the extended double-precision floating-point value `a' to an integer,
2150: | and returns the result as an extended quadruple-precision floating-point
2151: | value. The operation is performed according to the IEC/IEEE Standard for
2152: | Binary Floating-Point Arithmetic.
2153: *----------------------------------------------------------------------------*/
2154:
2155: floatx80 floatx80_round_to_int(floatx80 a, float_status *status)
2156: {
2157: flag aSign;
2158: int32_t aExp;
2159: uint64_t lastBitMask, roundBitsMask;
2160: floatx80 z;
2161:
2162: if (floatx80_invalid_encoding(a)) {
2163: float_raise(float_flag_invalid, status);
2164: return floatx80_default_nan(status);
2165: }
2166: aExp = extractFloatx80Exp( a );
2167: if ( 0x403E <= aExp ) {
2168: if ( ( aExp == 0x7FFF ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) {
2169: return propagateFloatx80NaNOneArg(a, status);
2170: }
2171: return a;
2172: }
2173: if ( aExp < 0x3FFF ) {
2174: if ( ( aExp == 0 )
2175: #ifdef SOFTFLOAT_68K
2176: && ( (uint64_t) extractFloatx80Frac( a ) == 0 ) ) {
2177: #else
2178: && ( (uint64_t) ( extractFloatx80Frac( a )<<1 ) == 0 ) ) {
2179: #endif
2180: return a;
2181: }
2182: status->float_exception_flags |= float_flag_inexact;
2183: aSign = extractFloatx80Sign( a );
2184: switch (status->float_rounding_mode) {
2185: case float_round_nearest_even:
2186: if ( ( aExp == 0x3FFE ) && (uint64_t) ( extractFloatx80Frac( a )<<1 )
2187: ) {
2188: return
2189: packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
2190: }
2191: break;
2192: case float_round_ties_away:
2193: if (aExp == 0x3FFE) {
2194: return packFloatx80(aSign, 0x3FFF, LIT64(0x8000000000000000));
2195: }
2196: break;
2197: case float_round_down:
2198: return
2199: aSign ?
2200: packFloatx80( 1, 0x3FFF, LIT64( 0x8000000000000000 ) )
2201: : packFloatx80( 0, 0, 0 );
2202: case float_round_up:
2203: return
2204: aSign ? packFloatx80( 1, 0, 0 )
2205: : packFloatx80( 0, 0x3FFF, LIT64( 0x8000000000000000 ) );
2206: }
2207: return packFloatx80( aSign, 0, 0 );
2208: }
2209: lastBitMask = 1;
2210: lastBitMask <<= 0x403E - aExp;
2211: roundBitsMask = lastBitMask - 1;
2212: z = a;
2213: switch (status->float_rounding_mode) {
2214: case float_round_nearest_even:
2215: z.low += lastBitMask>>1;
2216: if ((z.low & roundBitsMask) == 0) {
2217: z.low &= ~lastBitMask;
2218: }
2219: break;
2220: case float_round_ties_away:
2221: z.low += lastBitMask >> 1;
2222: break;
2223: case float_round_to_zero:
2224: break;
2225: case float_round_up:
2226: if (!extractFloatx80Sign(z)) {
2227: z.low += roundBitsMask;
2228: }
2229: break;
2230: case float_round_down:
2231: if (extractFloatx80Sign(z)) {
2232: z.low += roundBitsMask;
2233: }
2234: break;
2235: default:
2236: abort();
2237: }
2238: z.low &= ~ roundBitsMask;
2239: if ( z.low == 0 ) {
2240: ++z.high;
2241: z.low = LIT64( 0x8000000000000000 );
2242: }
2243: if (z.low != a.low) {
2244: status->float_exception_flags |= float_flag_inexact;
2245: }
2246: return z;
2247:
2248: }
2249:
2250: #ifdef SOFTFLOAT_68K // 09-01-2017: Added for Previous
2251: floatx80 floatx80_round_to_int_toward_zero( floatx80 a, float_status *status)
2252: {
2253: flag aSign;
2254: int32_t aExp;
2255: uint64_t lastBitMask, roundBitsMask;
2256: floatx80 z;
2257:
2258: aExp = extractFloatx80Exp( a );
2259: if ( 0x403E <= aExp ) {
2260: if ( ( aExp == 0x7FFF ) && (uint64_t) ( extractFloatx80Frac( a )<<1 ) ) {
2261: return propagateFloatx80NaNOneArg( a, status );
2262: }
2263: return a;
2264: }
2265: if ( aExp < 0x3FFF ) {
2266: if ( ( aExp == 0 )
2267: #ifdef SOFTFLOAT_68K
2268: && ( (uint64_t) extractFloatx80Frac( a ) == 0 ) ) {
2269: #else
2270: && ( (uint64_t) ( extractFloatx80Frac( a )<<1 ) == 0 ) ) {
2271: #endif
2272: return a;
2273: }
2274: status->float_exception_flags |= float_flag_inexact;
2275: aSign = extractFloatx80Sign( a );
2276: return packFloatx80( aSign, 0, 0 );
2277: }
2278: lastBitMask = 1;
2279: lastBitMask <<= 0x403E - aExp;
2280: roundBitsMask = lastBitMask - 1;
2281: z = a;
2282: z.low &= ~ roundBitsMask;
2283: if ( z.low == 0 ) {
2284: ++z.high;
2285: z.low = LIT64( 0x8000000000000000 );
2286: }
2287: if ( z.low != a.low ) status->float_exception_flags |= float_flag_inexact;
2288: return z;
2289:
2290: }
2291: #endif // End of addition for Previous
2292:
2293: /*----------------------------------------------------------------------------
2294: | Returns the result of adding the absolute values of the extended double-
2295: | precision floating-point values `a' and `b'. If `zSign' is 1, the sum is
2296: | negated before being returned. `zSign' is ignored if the result is a NaN.
2297: | The addition is performed according to the IEC/IEEE Standard for Binary
2298: | Floating-Point Arithmetic.
2299: *----------------------------------------------------------------------------*/
2300:
2301: static floatx80 addFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
2302: float_status *status)
2303: {
2304: int32_t aExp, bExp, zExp;
2305: uint64_t aSig, bSig, zSig0, zSig1;
2306: int32_t expDiff;
2307:
2308: aSig = extractFloatx80Frac( a );
2309: aExp = extractFloatx80Exp( a );
2310: bSig = extractFloatx80Frac( b );
2311: bExp = extractFloatx80Exp( b );
2312: #ifdef SOFTFLOAT_68K
2313: if ( aExp == 0 ) {
2314: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2315: }
2316: if ( bExp == 0 ) {
2317: normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
2318: }
2319: #endif
2320: expDiff = aExp - bExp;
2321: if ( 0 < expDiff ) {
2322: if ( aExp == 0x7FFF ) {
2323: if ((uint64_t)(aSig << 1)) {
2324: return propagateFloatx80NaN(a, b, status);
2325: }
2326: return a;
2327: }
2328: #ifndef SOFTFLOAT_68K
2329: if ( bExp == 0 ) --expDiff;
2330: #endif
2331: shift64ExtraRightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
2332: zExp = aExp;
2333: }
2334: else if ( expDiff < 0 ) {
2335: if ( bExp == 0x7FFF ) {
2336: if ((uint64_t)(bSig << 1)) {
2337: return propagateFloatx80NaN(a, b, status);
2338: }
2339: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
2340: }
2341: #ifndef SOFTFLOAT_68K
2342: if ( aExp == 0 ) ++expDiff;
2343: #endif
2344: shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
2345: zExp = bExp;
2346: }
2347: else {
2348: if ( aExp == 0x7FFF ) {
2349: if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) {
2350: return propagateFloatx80NaN(a, b, status);
2351: }
2352: return a;
2353: }
2354: zSig1 = 0;
2355: zSig0 = aSig + bSig;
2356: #ifndef SOFTFLOAT_68K
2357: if ( aExp == 0 ) {
2358: normalizeFloatx80Subnormal( zSig0, &zExp, &zSig0 );
2359: goto roundAndPack;
2360: }
2361: #endif
2362: zExp = aExp;
2363: #ifdef SOFTFLOAT_68K
2364: if ( aSig == 0 && bSig == 0 ) return packFloatx80( zSign, 0, 0 );
2365: if ( aSig == 0 || bSig == 0 ) goto roundAndPack;
2366: #endif
2367: goto shiftRight1;
2368: }
2369: zSig0 = aSig + bSig;
2370: if ( (int64_t) zSig0 < 0 ) goto roundAndPack;
2371: shiftRight1:
2372: shift64ExtraRightJamming( zSig0, zSig1, 1, &zSig0, &zSig1 );
2373: zSig0 |= LIT64( 0x8000000000000000 );
2374: ++zExp;
2375: roundAndPack:
2376: return roundAndPackFloatx80(status->floatx80_rounding_precision,
2377: zSign, zExp, zSig0, zSig1, status);
2378: }
2379:
2380: /*----------------------------------------------------------------------------
2381: | Returns the result of subtracting the absolute values of the extended
2382: | double-precision floating-point values `a' and `b'. If `zSign' is 1, the
2383: | difference is negated before being returned. `zSign' is ignored if the
2384: | result is a NaN. The subtraction is performed according to the IEC/IEEE
2385: | Standard for Binary Floating-Point Arithmetic.
2386: *----------------------------------------------------------------------------*/
2387:
2388: static floatx80 subFloatx80Sigs(floatx80 a, floatx80 b, flag zSign,
2389: float_status *status)
2390: {
2391: int32_t aExp, bExp, zExp;
2392: uint64_t aSig, bSig, zSig0, zSig1;
2393: int32_t expDiff;
2394:
2395: aSig = extractFloatx80Frac( a );
2396: aExp = extractFloatx80Exp( a );
2397: bSig = extractFloatx80Frac( b );
2398: bExp = extractFloatx80Exp( b );
2399: expDiff = aExp - bExp;
2400: if ( 0 < expDiff ) goto aExpBigger;
2401: if ( expDiff < 0 ) goto bExpBigger;
2402: if ( aExp == 0x7FFF ) {
2403: if ( (uint64_t) ( ( aSig | bSig )<<1 ) ) {
2404: return propagateFloatx80NaN(a, b, status);
2405: }
2406: float_raise(float_flag_invalid, status);
2407: return floatx80_default_nan(status);
2408: }
2409: #ifndef SOFTFLOAT_68K
2410: if ( aExp == 0 ) {
2411: aExp = 1;
2412: bExp = 1;
2413: }
2414: #endif
2415: zSig1 = 0;
2416: if ( bSig < aSig ) goto aBigger;
2417: if ( aSig < bSig ) goto bBigger;
2418: return packFloatx80(status->float_rounding_mode == float_round_down, 0, 0);
2419: bExpBigger:
2420: if ( bExp == 0x7FFF ) {
2421: if ((uint64_t)(bSig << 1)) {
2422: return propagateFloatx80NaN(a, b, status);
2423: }
2424: return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) );
2425: }
2426: #ifndef SOFTFLOAT_68K
2427: if ( aExp == 0 ) ++expDiff;
2428: #endif
2429: shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );
2430: bBigger:
2431: sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );
2432: zExp = bExp;
2433: zSign ^= 1;
2434: goto normalizeRoundAndPack;
2435: aExpBigger:
2436: if ( aExp == 0x7FFF ) {
2437: if ((uint64_t)(aSig << 1)) {
2438: return propagateFloatx80NaN(a, b, status);
2439: }
2440: return a;
2441: }
2442: #ifndef SOFTFLOAT_68K
2443: if ( bExp == 0 ) --expDiff;
2444: #endif
2445: shift128RightJamming( bSig, 0, expDiff, &bSig, &zSig1 );
2446: aBigger:
2447: sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );
2448: zExp = aExp;
2449: normalizeRoundAndPack:
2450: return normalizeRoundAndPackFloatx80(status->floatx80_rounding_precision,
2451: zSign, zExp, zSig0, zSig1, status);
2452: }
2453:
2454: /*----------------------------------------------------------------------------
2455: | Returns the result of adding the extended double-precision floating-point
2456: | values `a' and `b'. The operation is performed according to the IEC/IEEE
2457: | Standard for Binary Floating-Point Arithmetic.
2458: *----------------------------------------------------------------------------*/
2459:
2460: floatx80 floatx80_add(floatx80 a, floatx80 b, float_status *status)
2461: {
2462: flag aSign, bSign;
2463:
2464: if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
2465: float_raise(float_flag_invalid, status);
2466: return floatx80_default_nan(status);
2467: }
2468: aSign = extractFloatx80Sign( a );
2469: bSign = extractFloatx80Sign( b );
2470: if ( aSign == bSign ) {
2471: return addFloatx80Sigs(a, b, aSign, status);
2472: }
2473: else {
2474: return subFloatx80Sigs(a, b, aSign, status);
2475: }
2476:
2477: }
2478:
2479: /*----------------------------------------------------------------------------
2480: | Returns the result of subtracting the extended double-precision floating-
2481: | point values `a' and `b'. The operation is performed according to the
2482: | IEC/IEEE Standard for Binary Floating-Point Arithmetic.
2483: *----------------------------------------------------------------------------*/
2484:
2485: floatx80 floatx80_sub(floatx80 a, floatx80 b, float_status *status)
2486: {
2487: flag aSign, bSign;
2488:
2489: if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
2490: float_raise(float_flag_invalid, status);
2491: return floatx80_default_nan(status);
2492: }
2493: aSign = extractFloatx80Sign( a );
2494: bSign = extractFloatx80Sign( b );
2495: if ( aSign == bSign ) {
2496: return subFloatx80Sigs(a, b, aSign, status);
2497: }
2498: else {
2499: return addFloatx80Sigs(a, b, aSign, status);
2500: }
2501:
2502: }
2503:
2504: /*----------------------------------------------------------------------------
2505: | Returns the result of multiplying the extended double-precision floating-
2506: | point values `a' and `b'. The operation is performed according to the
2507: | IEC/IEEE Standard for Binary Floating-Point Arithmetic.
2508: *----------------------------------------------------------------------------*/
2509:
2510: floatx80 floatx80_mul(floatx80 a, floatx80 b, float_status *status)
2511: {
2512: flag aSign, bSign, zSign;
2513: int32_t aExp, bExp, zExp;
2514: uint64_t aSig, bSig, zSig0, zSig1;
2515:
2516: if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
2517: float_raise(float_flag_invalid, status);
2518: return floatx80_default_nan(status);
2519: }
2520: aSig = extractFloatx80Frac( a );
2521: aExp = extractFloatx80Exp( a );
2522: aSign = extractFloatx80Sign( a );
2523: bSig = extractFloatx80Frac( b );
2524: bExp = extractFloatx80Exp( b );
2525: bSign = extractFloatx80Sign( b );
2526: zSign = aSign ^ bSign;
2527: if ( aExp == 0x7FFF ) {
2528: if ( (uint64_t) ( aSig<<1 )
2529: || ( ( bExp == 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) {
2530: return propagateFloatx80NaN(a, b, status);
2531: }
2532: if ( ( bExp | bSig ) == 0 ) goto invalid;
2533: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
2534: }
2535: if ( bExp == 0x7FFF ) {
2536: if ((uint64_t)(bSig << 1)) {
2537: return propagateFloatx80NaN(a, b, status);
2538: }
2539: if ( ( aExp | aSig ) == 0 ) {
2540: invalid:
2541: float_raise(float_flag_invalid, status);
2542: return floatx80_default_nan(status);
2543: }
2544: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
2545: }
2546: if ( aExp == 0 ) {
2547: if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
2548: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2549: }
2550: if ( bExp == 0 ) {
2551: if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
2552: normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
2553: }
2554: zExp = aExp + bExp - 0x3FFE;
2555: mul64To128( aSig, bSig, &zSig0, &zSig1 );
2556: if ( 0 < (int64_t) zSig0 ) {
2557: shortShift128Left( zSig0, zSig1, 1, &zSig0, &zSig1 );
2558: --zExp;
2559: }
2560: return roundAndPackFloatx80(status->floatx80_rounding_precision,
2561: zSign, zExp, zSig0, zSig1, status);
2562: }
2563:
2564: #ifdef SOFTFLOAT_68K // 21-01-2017: Added for Previous
2565: floatx80 floatx80_sglmul( floatx80 a, floatx80 b, float_status *status )
2566: {
2567: flag aSign, bSign, zSign;
2568: int32_t aExp, bExp, zExp;
2569: uint64_t aSig, bSig, zSig0, zSig1;
2570: floatx80 z;
2571:
2572: aSig = extractFloatx80Frac( a );
2573: aExp = extractFloatx80Exp( a );
2574: aSign = extractFloatx80Sign( a );
2575: bSig = extractFloatx80Frac( b );
2576: bExp = extractFloatx80Exp( b );
2577: bSign = extractFloatx80Sign( b );
2578: zSign = aSign ^ bSign;
2579: if ( aExp == 0x7FFF ) {
2580: if ( (uint64_t) ( aSig<<1 )
2581: || ( ( bExp == 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) {
2582: return propagateFloatx80NaN( a, b, status );
2583: }
2584: if ( ( bExp | bSig ) == 0 ) goto invalid;
2585: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
2586: }
2587: if ( bExp == 0x7FFF ) {
2588: if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status );
2589: if ( ( aExp | aSig ) == 0 ) {
2590: invalid:
2591: float_raise( float_flag_invalid, status );
2592: z.low = floatx80_default_nan_low;
2593: z.high = floatx80_default_nan_high;
2594: return z;
2595: }
2596: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
2597: }
2598: if ( aExp == 0 ) {
2599: if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
2600: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2601: }
2602: if ( bExp == 0 ) {
2603: if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
2604: normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
2605: }
2606: aSig &= LIT64( 0xFFFFFF0000000000 );
2607: bSig &= LIT64( 0xFFFFFF0000000000 );
2608: zExp = aExp + bExp - 0x3FFE;
2609: mul64To128( aSig, bSig, &zSig0, &zSig1 );
2610: if ( 0 < (int64_t) zSig0 ) {
2611: shortShift128Left( zSig0, zSig1, 1, &zSig0, &zSig1 );
2612: --zExp;
2613: }
2614: return roundSigAndPackFloatx80( 32, zSign, zExp, zSig0, zSig1, status);
2615:
2616: }
2617: #endif // End of addition for Previous
2618:
2619:
2620: /*----------------------------------------------------------------------------
2621: | Returns the result of dividing the extended double-precision floating-point
2622: | value `a' by the corresponding value `b'. The operation is performed
2623: | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
2624: *----------------------------------------------------------------------------*/
2625:
2626: floatx80 floatx80_div(floatx80 a, floatx80 b, float_status *status)
2627: {
2628: flag aSign, bSign, zSign;
2629: int32_t aExp, bExp, zExp;
2630: uint64_t aSig, bSig, zSig0, zSig1;
2631: uint64_t rem0, rem1, rem2, term0, term1, term2;
2632:
2633: if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
2634: float_raise(float_flag_invalid, status);
2635: return floatx80_default_nan(status);
2636: }
2637: aSig = extractFloatx80Frac( a );
2638: aExp = extractFloatx80Exp( a );
2639: aSign = extractFloatx80Sign( a );
2640: bSig = extractFloatx80Frac( b );
2641: bExp = extractFloatx80Exp( b );
2642: bSign = extractFloatx80Sign( b );
2643: zSign = aSign ^ bSign;
2644: if ( aExp == 0x7FFF ) {
2645: if ((uint64_t)(aSig << 1)) {
2646: return propagateFloatx80NaN(a, b, status);
2647: }
2648: if ( bExp == 0x7FFF ) {
2649: if ((uint64_t)(bSig << 1)) {
2650: return propagateFloatx80NaN(a, b, status);
2651: }
2652: goto invalid;
2653: }
2654: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
2655: }
2656: if ( bExp == 0x7FFF ) {
2657: if ((uint64_t)(bSig << 1)) {
2658: return propagateFloatx80NaN(a, b, status);
2659: }
2660: return packFloatx80( zSign, 0, 0 );
2661: }
2662: if ( bExp == 0 ) {
2663: if ( bSig == 0 ) {
2664: if ( ( aExp | aSig ) == 0 ) {
2665: invalid:
2666: float_raise(float_flag_invalid, status);
2667: return floatx80_default_nan(status);
2668: }
2669: float_raise(float_flag_divbyzero, status);
2670: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
2671: }
2672: normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
2673: }
2674: if ( aExp == 0 ) {
2675: if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
2676: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2677: }
2678: zExp = aExp - bExp + 0x3FFE;
2679: rem1 = 0;
2680: if ( bSig <= aSig ) {
2681: shift128Right( aSig, 0, 1, &aSig, &rem1 );
2682: ++zExp;
2683: }
2684: zSig0 = estimateDiv128To64( aSig, rem1, bSig );
2685: mul64To128( bSig, zSig0, &term0, &term1 );
2686: sub128( aSig, rem1, term0, term1, &rem0, &rem1 );
2687: while ( (int64_t) rem0 < 0 ) {
2688: --zSig0;
2689: add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
2690: }
2691: zSig1 = estimateDiv128To64( rem1, 0, bSig );
2692: if ( (uint64_t) ( zSig1<<1 ) <= 8 ) {
2693: mul64To128( bSig, zSig1, &term1, &term2 );
2694: sub128( rem1, 0, term1, term2, &rem1, &rem2 );
2695: while ( (int64_t) rem1 < 0 ) {
2696: --zSig1;
2697: add128( rem1, rem2, 0, bSig, &rem1, &rem2 );
2698: }
2699: zSig1 |= ( ( rem1 | rem2 ) != 0 );
2700: }
2701: return roundAndPackFloatx80(status->floatx80_rounding_precision,
2702: zSign, zExp, zSig0, zSig1, status);
2703: }
2704:
2705: #ifdef SOFTFLOAT_68K // 21-01-2017: Addition for Previous
2706: floatx80 floatx80_sgldiv( floatx80 a, floatx80 b, float_status *status )
2707: {
2708: flag aSign, bSign, zSign;
2709: int32_t aExp, bExp, zExp;
2710: uint64_t aSig, bSig, zSig0, zSig1;
2711: uint64_t rem0, rem1, rem2, term0, term1, term2;
2712: floatx80 z;
2713:
2714: aSig = extractFloatx80Frac( a );
2715: aExp = extractFloatx80Exp( a );
2716: aSign = extractFloatx80Sign( a );
2717: bSig = extractFloatx80Frac( b );
2718: bExp = extractFloatx80Exp( b );
2719: bSign = extractFloatx80Sign( b );
2720: zSign = aSign ^ bSign;
2721: if ( aExp == 0x7FFF ) {
2722: if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b, status );
2723: if ( bExp == 0x7FFF ) {
2724: if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status );
2725: goto invalid;
2726: }
2727: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
2728: }
2729: if ( bExp == 0x7FFF ) {
2730: if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status );
2731: return packFloatx80( zSign, 0, 0 );
2732: }
2733: if ( bExp == 0 ) {
2734: if ( bSig == 0 ) {
2735: if ( ( aExp | aSig ) == 0 ) {
2736: invalid:
2737: float_raise( float_flag_invalid, status );
2738: z.low = floatx80_default_nan_low;
2739: z.high = floatx80_default_nan_high;
2740: return z;
2741: }
2742: float_raise( float_flag_divbyzero, status );
2743: return packFloatx80( zSign, 0x7FFF, floatx80_default_infinity_low );
2744: }
2745: normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
2746: }
2747: if ( aExp == 0 ) {
2748: if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
2749: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
2750: }
2751:
2752: zExp = aExp - bExp + 0x3FFE;
2753: rem1 = 0;
2754: if ( bSig <= aSig ) {
2755: shift128Right( aSig, 0, 1, &aSig, &rem1 );
2756: ++zExp;
2757: }
2758: zSig0 = estimateDiv128To64( aSig, rem1, bSig );
2759: mul64To128( bSig, zSig0, &term0, &term1 );
2760: sub128( aSig, rem1, term0, term1, &rem0, &rem1 );
2761: while ( (int64_t) rem0 < 0 ) {
2762: --zSig0;
2763: add128( rem0, rem1, 0, bSig, &rem0, &rem1 );
2764: }
2765: zSig1 = estimateDiv128To64( rem1, 0, bSig );
2766: if ( (uint64_t) ( zSig1<<1 ) <= 8 ) {
2767: mul64To128( bSig, zSig1, &term1, &term2 );
2768: sub128( rem1, 0, term1, term2, &rem1, &rem2 );
2769: while ( (int64_t) rem1 < 0 ) {
2770: --zSig1;
2771: add128( rem1, rem2, 0, bSig, &rem1, &rem2 );
2772: }
2773: zSig1 |= ( ( rem1 | rem2 ) != 0 );
2774: }
2775: return roundSigAndPackFloatx80( 32, zSign, zExp, zSig0, zSig1, status);
2776:
2777: }
2778: #endif // End of addition for Previous
2779:
2780:
2781: /*----------------------------------------------------------------------------
2782: | Returns the remainder of the extended double-precision floating-point value
2783: | `a' with respect to the corresponding value `b'. The operation is performed
2784: | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
2785: *----------------------------------------------------------------------------*/
2786:
2787: #ifndef SOFTFLOAT_68K
2788: floatx80 floatx80_rem(floatx80 a, floatx80 b, float_status *status)
2789: {
2790: flag aSign, zSign;
2791: int32_t aExp, bExp, expDiff;
2792: uint64_t aSig0, aSig1, bSig;
2793: uint64_t q, term0, term1, alternateASig0, alternateASig1;
2794:
2795: if (floatx80_invalid_encoding(a) || floatx80_invalid_encoding(b)) {
2796: float_raise(float_flag_invalid, status);
2797: return floatx80_default_nan(status);
2798: }
2799: aSig0 = extractFloatx80Frac( a );
2800: aExp = extractFloatx80Exp( a );
2801: aSign = extractFloatx80Sign( a );
2802: bSig = extractFloatx80Frac( b );
2803: bExp = extractFloatx80Exp( b );
2804: if ( aExp == 0x7FFF ) {
2805: if ( (uint64_t) ( aSig0<<1 )
2806: || ( ( bExp == 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) {
2807: return propagateFloatx80NaN(a, b, status);
2808: }
2809: goto invalid;
2810: }
2811: if ( bExp == 0x7FFF ) {
2812: if ((uint64_t)(bSig << 1)) {
2813: return propagateFloatx80NaN(a, b, status);
2814: }
2815: return a;
2816: }
2817: if ( bExp == 0 ) {
2818: if ( bSig == 0 ) {
2819: invalid:
2820: float_raise(float_flag_invalid, status);
2821: return floatx80_default_nan(status);
2822: }
2823: normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
2824: }
2825: if ( aExp == 0 ) {
2826: if ( (uint64_t) ( aSig0<<1 ) == 0 ) return a;
2827: normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 );
2828: }
2829: bSig |= LIT64( 0x8000000000000000 );
2830: zSign = aSign;
2831: expDiff = aExp - bExp;
2832: aSig1 = 0;
2833: if ( expDiff < 0 ) {
2834: if ( expDiff < -1 ) return a;
2835: shift128Right( aSig0, 0, 1, &aSig0, &aSig1 );
2836: expDiff = 0;
2837: }
2838: q = ( bSig <= aSig0 );
2839: if ( q ) aSig0 -= bSig;
2840: expDiff -= 64;
2841: while ( 0 < expDiff ) {
2842: q = estimateDiv128To64( aSig0, aSig1, bSig );
2843: q = ( 2 < q ) ? q - 2 : 0;
2844: mul64To128( bSig, q, &term0, &term1 );
2845: sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
2846: shortShift128Left( aSig0, aSig1, 62, &aSig0, &aSig1 );
2847: expDiff -= 62;
2848: }
2849: expDiff += 64;
2850: if ( 0 < expDiff ) {
2851: q = estimateDiv128To64( aSig0, aSig1, bSig );
2852: q = ( 2 < q ) ? q - 2 : 0;
2853: q >>= 64 - expDiff;
2854: mul64To128( bSig, q<<( 64 - expDiff ), &term0, &term1 );
2855: sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
2856: shortShift128Left( 0, bSig, 64 - expDiff, &term0, &term1 );
2857: while ( le128( term0, term1, aSig0, aSig1 ) ) {
2858: ++q;
2859: sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
2860: }
2861: }
2862: else {
2863: term1 = 0;
2864: term0 = bSig;
2865: }
2866: sub128( term0, term1, aSig0, aSig1, &alternateASig0, &alternateASig1 );
2867: if ( lt128( alternateASig0, alternateASig1, aSig0, aSig1 )
2868: || ( eq128( alternateASig0, alternateASig1, aSig0, aSig1 )
2869: && ( q & 1 ) )
2870: ) {
2871: aSig0 = alternateASig0;
2872: aSig1 = alternateASig1;
2873: zSign = ! zSign;
2874: }
2875: return
2876: normalizeRoundAndPackFloatx80(
2877: 80, zSign, bExp + expDiff, aSig0, aSig1, status);
2878:
2879: }
2880: #else // 09-01-2017: Modified version for Previous
2881: floatx80 floatx80_rem( floatx80 a, floatx80 b, uint64_t *q, flag *s, float_status *status )
2882: {
2883: flag aSign, bSign, zSign;
2884: int32_t aExp, bExp, expDiff;
2885: uint64_t aSig0, aSig1, bSig;
2886: uint64_t qTemp, term0, term1, alternateASig0, alternateASig1;
2887: floatx80 z;
2888:
2889: aSig0 = extractFloatx80Frac( a );
2890: aExp = extractFloatx80Exp( a );
2891: aSign = extractFloatx80Sign( a );
2892: bSig = extractFloatx80Frac( b );
2893: bExp = extractFloatx80Exp( b );
2894: bSign = extractFloatx80Sign( b );
2895:
2896: if ( aExp == 0x7FFF ) {
2897: if ( (uint64_t) ( aSig0<<1 )
2898: || ( ( bExp == 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) {
2899: return propagateFloatx80NaN( a, b, status );
2900: }
2901: goto invalid;
2902: }
2903: if ( bExp == 0x7FFF ) {
2904: if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status );
2905: *s = (aSign != bSign);
2906: *q = 0;
2907: return a;
2908: }
2909: if ( bExp == 0 ) {
2910: if ( bSig == 0 ) {
2911: invalid:
2912: float_raise( float_flag_invalid, status );
2913: z.low = floatx80_default_nan_low;
2914: z.high = floatx80_default_nan_high;
2915: return z;
2916: }
2917: normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
2918: }
2919: if ( aExp == 0 ) {
2920: #ifdef SOFTFLOAT_68K
2921: if ( aSig0 == 0 ) {
2922: *s = (aSign != bSign);
2923: *q = 0;
2924: return a;
2925: }
2926: #else
2927: if ( (uint64_t) ( aSig0<<1 ) == 0 ) return a;
2928: #endif
2929: normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 );
2930: }
2931: bSig |= LIT64( 0x8000000000000000 );
2932: zSign = aSign;
2933: expDiff = aExp - bExp;
2934: *s = (aSign != bSign);
2935: aSig1 = 0;
2936: if ( expDiff < 0 ) {
2937: if ( expDiff < -1 ) return a;
2938: shift128Right( aSig0, 0, 1, &aSig0, &aSig1 );
2939: expDiff = 0;
2940: }
2941: qTemp = ( bSig <= aSig0 );
2942: if ( qTemp ) aSig0 -= bSig;
2943: *q = ( expDiff > 63 ) ? 0 : ( qTemp<<expDiff );
2944: expDiff -= 64;
2945: while ( 0 < expDiff ) {
2946: qTemp = estimateDiv128To64( aSig0, aSig1, bSig );
2947: qTemp = ( 2 < qTemp ) ? qTemp - 2 : 0;
2948: mul64To128( bSig, qTemp, &term0, &term1 );
2949: sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
2950: shortShift128Left( aSig0, aSig1, 62, &aSig0, &aSig1 );
2951: *q = ( expDiff > 63 ) ? 0 : ( qTemp<<expDiff );
2952: expDiff -= 62;
2953: }
2954: expDiff += 64;
2955: if ( 0 < expDiff ) {
2956: qTemp = estimateDiv128To64( aSig0, aSig1, bSig );
2957: qTemp = ( 2 < qTemp ) ? qTemp - 2 : 0;
2958: qTemp >>= 64 - expDiff;
2959: mul64To128( bSig, qTemp<<( 64 - expDiff ), &term0, &term1 );
2960: sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
2961: shortShift128Left( 0, bSig, 64 - expDiff, &term0, &term1 );
2962: while ( le128( term0, term1, aSig0, aSig1 ) ) {
2963: ++qTemp;
2964: sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
2965: }
2966: *q += qTemp;
2967: }
2968: else {
2969: term1 = 0;
2970: term0 = bSig;
2971: }
2972: sub128( term0, term1, aSig0, aSig1, &alternateASig0, &alternateASig1 );
2973: if ( lt128( alternateASig0, alternateASig1, aSig0, aSig1 )
2974: || ( eq128( alternateASig0, alternateASig1, aSig0, aSig1 )
2975: && ( qTemp & 1 ) )
2976: ) {
2977: aSig0 = alternateASig0;
2978: aSig1 = alternateASig1;
2979: zSign = ! zSign;
2980: ++*q;
2981: }
2982: return
2983: normalizeRoundAndPackFloatx80(
2984: 80, zSign, bExp + expDiff, aSig0, aSig1, status );
2985:
2986: }
2987: #endif // End of modification
2988:
2989:
2990: #ifdef SOFTFLOAT_68K // 08-01-2017: Added for Previous
2991: /*----------------------------------------------------------------------------
2992: | Returns the modulo remainder of the extended double-precision floating-point
2993: | value `a' with respect to the corresponding value `b'.
2994: *----------------------------------------------------------------------------*/
2995:
2996: floatx80 floatx80_mod( floatx80 a, floatx80 b, uint64_t *q, flag *s, float_status *status )
2997: {
2998: flag aSign, bSign, zSign;
2999: int32_t aExp, bExp, expDiff;
3000: uint64_t aSig0, aSig1, bSig;
3001: uint64_t qTemp, term0, term1;
3002: floatx80 z;
3003:
3004: aSig0 = extractFloatx80Frac( a );
3005: aExp = extractFloatx80Exp( a );
3006: aSign = extractFloatx80Sign( a );
3007: bSig = extractFloatx80Frac( b );
3008: bExp = extractFloatx80Exp( b );
3009: bSign = extractFloatx80Sign( b );
3010:
3011: if ( aExp == 0x7FFF ) {
3012: if ( (uint64_t) ( aSig0<<1 )
3013: || ( ( bExp == 0x7FFF ) && (uint64_t) ( bSig<<1 ) ) ) {
3014: return propagateFloatx80NaN( a, b, status );
3015: }
3016: goto invalid;
3017: }
3018: if ( bExp == 0x7FFF ) {
3019: if ( (uint64_t) ( bSig<<1 ) ) return propagateFloatx80NaN( a, b, status );
3020: *s = (aSign != bSign);
3021: *q = 0;
3022: return a;
3023: }
3024: if ( bExp == 0 ) {
3025: if ( bSig == 0 ) {
3026: invalid:
3027: float_raise( float_flag_invalid, status );
3028: z.low = floatx80_default_nan_low;
3029: z.high = floatx80_default_nan_high;
3030: return z;
3031: }
3032: normalizeFloatx80Subnormal( bSig, &bExp, &bSig );
3033: }
3034: if ( aExp == 0 ) {
3035: #ifdef SOFTFLOAT_68K
3036: if ( aSig0 == 0 ) {
3037: *s = (aSign != bSign);
3038: *q = 0;
3039: return a;
3040: }
3041: #else
3042: if ( (uint64_t) ( aSig0<<1 ) == 0 ) return a;
3043: #endif
3044: normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 );
3045: }
3046: bSig |= LIT64( 0x8000000000000000 );
3047: zSign = aSign;
3048: expDiff = aExp - bExp;
3049: *s = (aSign != bSign);
3050: aSig1 = 0;
3051: if ( expDiff < 0 ) return a;
3052: qTemp = ( bSig <= aSig0 );
3053: if ( qTemp ) aSig0 -= bSig;
3054: *q = ( expDiff > 63 ) ? 0 : ( qTemp<<expDiff );
3055: expDiff -= 64;
3056: while ( 0 < expDiff ) {
3057: qTemp = estimateDiv128To64( aSig0, aSig1, bSig );
3058: qTemp = ( 2 < qTemp ) ? qTemp - 2 : 0;
3059: mul64To128( bSig, qTemp, &term0, &term1 );
3060: sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
3061: shortShift128Left( aSig0, aSig1, 62, &aSig0, &aSig1 );
3062: *q = ( expDiff > 63 ) ? 0 : ( qTemp<<expDiff );
3063: expDiff -= 62;
3064: }
3065: expDiff += 64;
3066: if ( 0 < expDiff ) {
3067: qTemp = estimateDiv128To64( aSig0, aSig1, bSig );
3068: qTemp = ( 2 < qTemp ) ? qTemp - 2 : 0;
3069: qTemp >>= 64 - expDiff;
3070: mul64To128( bSig, qTemp<<( 64 - expDiff ), &term0, &term1 );
3071: sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
3072: shortShift128Left( 0, bSig, 64 - expDiff, &term0, &term1 );
3073: while ( le128( term0, term1, aSig0, aSig1 ) ) {
3074: ++qTemp;
3075: sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );
3076: }
3077: *q += qTemp;
3078: }
3079: return
3080: normalizeRoundAndPackFloatx80(
3081: 80, zSign, bExp + expDiff, aSig0, aSig1, status );
3082:
3083: }
3084: #endif // end of addition for Previous
3085:
3086:
3087: /*----------------------------------------------------------------------------
3088: | Returns the square root of the extended double-precision floating-point
3089: | value `a'. The operation is performed according to the IEC/IEEE Standard
3090: | for Binary Floating-Point Arithmetic.
3091: *----------------------------------------------------------------------------*/
3092:
3093: floatx80 floatx80_sqrt(floatx80 a, float_status *status)
3094: {
3095: flag aSign;
3096: int32_t aExp, zExp;
3097: uint64_t aSig0, aSig1, zSig0, zSig1, doubleZSig0;
3098: uint64_t rem0, rem1, rem2, rem3, term0, term1, term2, term3;
3099:
3100: if (floatx80_invalid_encoding(a)) {
3101: float_raise(float_flag_invalid, status);
3102: return floatx80_default_nan(status);
3103: }
3104: aSig0 = extractFloatx80Frac( a );
3105: aExp = extractFloatx80Exp( a );
3106: aSign = extractFloatx80Sign( a );
3107: if ( aExp == 0x7FFF ) {
3108: if ((uint64_t)(aSig0 << 1)) {
3109: return propagateFloatx80NaNOneArg(a, status);
3110: }
3111: if ( ! aSign ) return a;
3112: goto invalid;
3113: }
3114: if ( aSign ) {
3115: if ( ( aExp | aSig0 ) == 0 ) return a;
3116: invalid:
3117: float_raise(float_flag_invalid, status);
3118: return floatx80_default_nan(status);
3119: }
3120: if ( aExp == 0 ) {
3121: if ( aSig0 == 0 ) return packFloatx80( 0, 0, 0 );
3122: normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 );
3123: }
3124: zExp = ( ( aExp - 0x3FFF )>>1 ) + 0x3FFF;
3125: zSig0 = estimateSqrt32( aExp, aSig0>>32 );
3126: shift128Right( aSig0, 0, 2 + ( aExp & 1 ), &aSig0, &aSig1 );
3127: zSig0 = estimateDiv128To64( aSig0, aSig1, zSig0<<32 ) + ( zSig0<<30 );
3128: doubleZSig0 = zSig0<<1;
3129: mul64To128( zSig0, zSig0, &term0, &term1 );
3130: sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 );
3131: while ( (int64_t) rem0 < 0 ) {
3132: --zSig0;
3133: doubleZSig0 -= 2;
3134: add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 );
3135: }
3136: zSig1 = estimateDiv128To64( rem1, 0, doubleZSig0 );
3137: if ( ( zSig1 & LIT64( 0x3FFFFFFFFFFFFFFF ) ) <= 5 ) {
3138: if ( zSig1 == 0 ) zSig1 = 1;
3139: mul64To128( doubleZSig0, zSig1, &term1, &term2 );
3140: sub128( rem1, 0, term1, term2, &rem1, &rem2 );
3141: mul64To128( zSig1, zSig1, &term2, &term3 );
3142: sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 );
3143: while ( (int64_t) rem1 < 0 ) {
3144: --zSig1;
3145: shortShift128Left( 0, zSig1, 1, &term2, &term3 );
3146: term3 |= 1;
3147: term2 |= doubleZSig0;
3148: add192( rem1, rem2, rem3, 0, term2, term3, &rem1, &rem2, &rem3 );
3149: }
3150: zSig1 |= ( ( rem1 | rem2 | rem3 ) != 0 );
3151: }
3152: shortShift128Left( 0, zSig1, 1, &zSig0, &zSig1 );
3153: zSig0 |= doubleZSig0;
3154: return roundAndPackFloatx80(status->floatx80_rounding_precision,
3155: 0, zExp, zSig0, zSig1, status);
3156: }
3157:
3158:
3159: #ifdef SOFTFLOAT_68K // 07-01-2017: Added for Previous
3160: /*----------------------------------------------------------------------------
3161: | Returns the mantissa of the extended double-precision floating-point
3162: | value `a'.
3163: *----------------------------------------------------------------------------*/
3164:
3165: floatx80 floatx80_getman( floatx80 a, float_status *status)
3166: {
3167: flag aSign;
3168: int32_t aExp;
3169: uint64_t aSig;
3170:
3171: aSig = extractFloatx80Frac( a );
3172: aExp = extractFloatx80Exp( a );
3173: aSign = extractFloatx80Sign( a );
3174:
3175: if ( aExp == 0x7FFF ) {
3176: if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaNOneArg( a, status );
3177: float_raise( float_flag_invalid, status );
3178: a.low = floatx80_default_nan_low;
3179: a.high = floatx80_default_nan_high;
3180: return a;
3181: }
3182:
3183: if ( aExp == 0 ) {
3184: if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
3185: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3186: }
3187:
3188: return roundAndPackFloatx80(status->floatx80_rounding_precision, aSign, 0x3FFF, aSig, 0, status);
3189: }
3190:
3191: /*----------------------------------------------------------------------------
3192: | Returns the exponent of the extended double-precision floating-point
3193: | value `a' as an extended double-precision value.
3194: *----------------------------------------------------------------------------*/
3195:
3196: floatx80 floatx80_getexp( floatx80 a, float_status *status)
3197: {
3198: flag aSign;
3199: int32_t aExp;
3200: uint64_t aSig;
3201:
3202: aSig = extractFloatx80Frac( a );
3203: aExp = extractFloatx80Exp( a );
3204: aSign = extractFloatx80Sign( a );
3205:
3206: if ( aExp == 0x7FFF ) {
3207: if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaNOneArg( a, status );
3208: float_raise( float_flag_invalid, status );
3209: a.low = floatx80_default_nan_low;
3210: a.high = floatx80_default_nan_high;
3211: return a;
3212: }
3213:
3214: if ( aExp == 0 ) {
3215: if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
3216: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3217: }
3218:
3219: return int32_to_floatx80(aExp - 0x3FFF);
3220: }
3221:
3222: /*----------------------------------------------------------------------------
3223: | Scales extended double-precision floating-point value in operand `a' by
3224: | value `b'. The function truncates the value in the second operand 'b' to
3225: | an integral value and adds that value to the exponent of the operand 'a'.
3226: | The operation performed according to the IEC/IEEE Standard for Binary
3227: | Floating-Point Arithmetic.
3228: *----------------------------------------------------------------------------*/
3229:
3230: floatx80 floatx80_scale(floatx80 a, floatx80 b, float_status *status)
3231: {
3232: flag aSign, bSign;
3233: int32_t aExp, bExp, shiftCount;
3234: uint64_t aSig, bSig;
3235:
3236: aSig = extractFloatx80Frac(a);
3237: aExp = extractFloatx80Exp(a);
3238: aSign = extractFloatx80Sign(a);
3239: bSig = extractFloatx80Frac(b);
3240: bExp = extractFloatx80Exp(b);
3241: bSign = extractFloatx80Sign(b);
3242:
3243: if ( bExp == 0x7FFF ) {
3244: if ( (uint64_t) ( bSig<<1 ) ||
3245: ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) ) {
3246: return propagateFloatx80NaN( a, b, status );
3247: }
3248: float_raise( float_flag_invalid, status );
3249: a.low = floatx80_default_nan_low;
3250: a.high = floatx80_default_nan_high;
3251: return a;
3252: }
3253: if ( aExp == 0x7FFF ) {
3254: if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaN( a, b, status );
3255: return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
3256: }
3257: if ( aExp == 0 ) {
3258: if ( aSig == 0 ) return packFloatx80( aSign, 0, 0);
3259: if ( bExp < 0x3FFF ) return a;
3260: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3261: }
3262:
3263: if ( bExp < 0x3FFF ) return a;
3264:
3265: if ( 0x400F < bExp ) {
3266: aExp = bSign ? -0x6001 : 0xE000;
3267: return roundAndPackFloatx80(
3268: status->floatx80_rounding_precision, aSign, aExp, aSig, 0, status );
3269: }
3270:
3271: shiftCount = 0x403E - bExp;
3272: bSig >>= shiftCount;
3273: aExp = bSign ? ( aExp - bSig ) : ( aExp + bSig );
3274:
3275: return roundAndPackFloatx80(
3276: status->floatx80_rounding_precision, aSign, aExp, aSig, 0, status);
3277:
3278: }
3279:
3280: /*-----------------------------------------------------------------------------
3281: | Calculates the absolute value of the extended double-precision floating-point
3282: | value `a'. The operation is performed according to the IEC/IEEE Standard
3283: | for Binary Floating-Point Arithmetic.
3284: *----------------------------------------------------------------------------*/
3285:
3286: floatx80 floatx80_abs(floatx80 a, float_status *status)
3287: {
3288: int32_t aExp;
3289: uint64_t aSig;
3290:
3291: aSig = extractFloatx80Frac(a);
3292: aExp = extractFloatx80Exp(a);
3293:
3294: if ( aExp == 0x7FFF && (uint64_t) ( aSig<<1 ) ) {
3295: return propagateFloatx80NaNOneArg( a, status );
3296: }
3297:
3298: if ( aExp == 0 ) {
3299: if ( aSig == 0 ) return packFloatx80( 0, 0, 0 );
3300: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3301: }
3302:
3303: return roundAndPackFloatx80(
3304: status->floatx80_rounding_precision, 0, aExp, aSig, 0, status );
3305:
3306: }
3307:
3308: /*-----------------------------------------------------------------------------
3309: | Changes the sign of the extended double-precision floating-point value 'a'.
3310: | The operation is performed according to the IEC/IEEE Standard for Binary
3311: | Floating-Point Arithmetic.
3312: *----------------------------------------------------------------------------*/
3313:
3314: floatx80 floatx80_neg(floatx80 a, float_status *status)
3315: {
3316: flag aSign;
3317: int32_t aExp;
3318: uint64_t aSig;
3319:
3320: aSig = extractFloatx80Frac(a);
3321: aExp = extractFloatx80Exp(a);
3322: aSign = extractFloatx80Sign(a);
3323:
3324: if ( aExp == 0x7FFF && (uint64_t) ( aSig<<1 ) ) {
3325: return propagateFloatx80NaNOneArg( a, status );
3326: }
3327:
3328: aSign = !aSign;
3329:
3330: if ( aExp == 0 ) {
3331: if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
3332: normalizeFloatx80Subnormal( aSig, &aExp, &aSig );
3333: }
3334:
3335: return roundAndPackFloatx80(
3336: status->floatx80_rounding_precision, aSign, aExp, aSig, 0, status );
3337:
3338: }
3339:
3340: /*----------------------------------------------------------------------------
3341: | Returns the result of comparing the extended double-precision floating-
3342: | point values `a' and `b'. The result is abstracted for matching the
3343: | corresponding condition codes.
3344: *----------------------------------------------------------------------------*/
3345:
3346: floatx80 floatx80_cmp( floatx80 a, floatx80 b, float_status *status )
3347: {
3348: flag aSign, bSign;
3349: int32_t aExp, bExp;
3350: uint64_t aSig, bSig;
3351:
3352: aSig = extractFloatx80Frac( a );
3353: aExp = extractFloatx80Exp( a );
3354: aSign = extractFloatx80Sign( a );
3355: bSig = extractFloatx80Frac( b );
3356: bExp = extractFloatx80Exp( b );
3357: bSign = extractFloatx80Sign( b );
3358:
3359: if ( ( aExp == 0x7FFF && (uint64_t) ( aSig<<1 ) ) ||
3360: ( bExp == 0x7FFF && (uint64_t) ( bSig<<1 ) ) ) {
3361: return propagateFloatx80NaN( packFloatx80( 0, aExp, aSig ),
3362: packFloatx80( 0, bExp, bSig ), status );
3363: }
3364:
3365: if ( bExp < aExp ) return packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
3366: if ( aExp < bExp ) return packFloatx80( bSign ^ 1, 0x3FFF, LIT64( 0x8000000000000000 ) );
3367:
3368: if ( aExp == 0x7FFF ) {
3369: if ( aSign == bSign ) return packFloatx80( aSign, 0, 0 );
3370: return packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
3371: }
3372:
3373: if ( bSig < aSig ) return packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
3374: if ( aSig < bSig ) return packFloatx80( bSign ^ 1, 0x3FFF, LIT64( 0x8000000000000000 ) );
3375:
3376: if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
3377:
3378: if ( aSign == bSign ) return packFloatx80( 0, 0, 0 );
3379:
3380: return packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
3381:
3382: }
3383:
3384: floatx80 floatx80_tst( floatx80 a, float_status *status )
3385: {
3386: int32_t aExp;
3387: uint64_t aSig;
3388:
3389: aSig = extractFloatx80Frac( a );
3390: aExp = extractFloatx80Exp( a );
3391:
3392: if ( aExp == 0x7FFF && (uint64_t) ( aSig<<1 ) )
3393: return propagateFloatx80NaNOneArg( a, status );
3394: return a;
3395: }
3396:
3397: floatx80 floatx80_move( floatx80 a, float_status *status )
3398: {
3399: flag aSign;
3400: int32_t aExp;
3401: uint64_t aSig;
3402:
3403: aSig = extractFloatx80Frac( a );
3404: aExp = extractFloatx80Exp( a );
3405: aSign = extractFloatx80Sign( a );
3406:
3407: if ( aExp == 0x7FFF ) {
3408: if ( (uint64_t) ( aSig<<1 ) ) return propagateFloatx80NaNOneArg( a, status );
3409: return a;
3410: }
3411: if ( aExp == 0 ) {
3412: if ( aSig == 0 ) return a;
3413: normalizeRoundAndPackFloatx80( status->floatx80_rounding_precision, aSign, aExp, aSig, 0, status );
3414: }
3415: return roundAndPackFloatx80( status->floatx80_rounding_precision, aSign, aExp, aSig, 0, status );
3416: }
3417:
3418: floatx80 floatx80_denormalize( floatx80 a, flag eSign)
3419: {
3420: flag aSign;
3421: int32_t aExp;
3422: uint64_t aSig;
3423: int32_t shiftCount;
3424:
3425: aSig = extractFloatx80Frac( a );
3426: aExp = extractFloatx80Exp( a );
3427: aSign = extractFloatx80Sign( a );
3428:
3429: if ( eSign ) {
3430: shiftCount = 0x8000 - aExp;
3431: aExp = 0;
3432: if (shiftCount > 63) {
3433: aSig = 0;
3434: } else {
3435: aSig >>= shiftCount;
3436: }
3437: }
3438: return packFloatx80(aSign, aExp, aSig);
3439: }
3440:
3441: #endif // End of addition for Previous
3442:
3443: /*----------------------------------------------------------------------------
3444: | Returns 1 if the extended double-precision floating-point value `a' is
3445: | equal to the corresponding value `b', and 0 otherwise. The comparison is
3446: | performed according to the IEC/IEEE Standard for Binary Floating-Point
3447: | Arithmetic.
3448: *----------------------------------------------------------------------------*/
3449:
3450: flag floatx80_eq( floatx80 a, floatx80 b, float_status *status )
3451: {
3452: if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
3453: && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
3454: || ( ( extractFloatx80Exp( b ) == 0x7FFF )
3455: && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
3456: ) {
3457: if ( floatx80_is_signaling_nan( a )
3458: || floatx80_is_signaling_nan( b ) ) {
3459: float_raise( float_flag_invalid, status );
3460: }
3461: return 0;
3462: }
3463: return
3464: ( a.low == b.low )
3465: && ( ( a.high == b.high )
3466: || ( ( a.low == 0 )
3467: && ( (uint16_t) ( ( a.high | b.high )<<1 ) == 0 ) )
3468: );
3469:
3470: }
3471:
3472: /*----------------------------------------------------------------------------
3473: | Returns 1 if the extended double-precision floating-point value `a' is
3474: | less than or equal to the corresponding value `b', and 0 otherwise. The
3475: | comparison is performed according to the IEC/IEEE Standard for Binary
3476: | Floating-Point Arithmetic.
3477: *----------------------------------------------------------------------------*/
3478:
3479: flag floatx80_le( floatx80 a, floatx80 b, float_status *status )
3480: {
3481: flag aSign, bSign;
3482:
3483: if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
3484: && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
3485: || ( ( extractFloatx80Exp( b ) == 0x7FFF )
3486: && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
3487: ) {
3488: float_raise( float_flag_invalid, status );
3489: return 0;
3490: }
3491: aSign = extractFloatx80Sign( a );
3492: bSign = extractFloatx80Sign( b );
3493: if ( aSign != bSign ) {
3494: return
3495: aSign
3496: || ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
3497: == 0 );
3498: }
3499: return
3500: aSign ? le128( b.high, b.low, a.high, a.low )
3501: : le128( a.high, a.low, b.high, b.low );
3502: }
3503:
3504: /*----------------------------------------------------------------------------
3505: | Returns 1 if the extended double-precision floating-point value `a' is
3506: | less than the corresponding value `b', and 0 otherwise. The comparison
3507: | is performed according to the IEC/IEEE Standard for Binary Floating-Point
3508: | Arithmetic.
3509: *----------------------------------------------------------------------------*/
3510:
3511: flag floatx80_lt( floatx80 a, floatx80 b, float_status *status )
3512: {
3513: flag aSign, bSign;
3514:
3515: if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
3516: && (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
3517: || ( ( extractFloatx80Exp( b ) == 0x7FFF )
3518: && (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
3519: ) {
3520: float_raise( float_flag_invalid, status );
3521: return 0;
3522: }
3523: aSign = extractFloatx80Sign( a );
3524: bSign = extractFloatx80Sign( b );
3525: if ( aSign != bSign ) {
3526: return
3527: aSign
3528: && ( ( ( (uint16_t) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )
3529: != 0 );
3530: }
3531: return
3532: aSign ? lt128( b.high, b.low, a.high, a.low )
3533: : lt128( a.high, a.low, b.high, b.low );
3534:
3535: }
3536:
3537:
3538: /*----------------------------------------------------------------------------
3539: | Returns the result of converting the 64-bit two's complement integer `a'
3540: | to the extended double-precision floating-point format. The conversion
3541: | is performed according to the IEC/IEEE Standard for Binary Floating-Point
3542: | Arithmetic.
3543: *----------------------------------------------------------------------------*/
3544:
3545: floatx80 int64_to_floatx80( int64_t a )
3546: {
3547: flag zSign;
3548: uint64_t absA;
3549: int8_t shiftCount;
3550:
3551: if ( a == 0 ) return packFloatx80( 0, 0, 0 );
3552: zSign = ( a < 0 );
3553: absA = zSign ? - a : a;
3554: shiftCount = countLeadingZeros64( absA );
3555: return packFloatx80( zSign, 0x403E - shiftCount, absA<<shiftCount );
3556: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.