test/testfloat/slowfloat-64.c

271     floatX ax;
273     ax.isNaN = FALSE;
274     ax.isInf = FALSE;
275     ax.sign = ( a < 0 );
276     ax.sig.a1 = 0;
277     ax.sig.a0 = ax.sign ? - (bits64) a : a;
279         ax.isZero = TRUE;
280         return ax;
282     ax.isZero = FALSE;
283     ax.sig.a0 <<= 24;
284     ax.exp = 31;
285     while ( ax.sig.a0 < LIT64( 0x0080000000000000 ) ) {
286         ax.sig.a0 <<= 1;
287         --ax.exp;
289     return ax;
293 static int32 floatXToInt32( floatX ax )
299     if ( ax.isInf || ax.isNaN ) {
301         return ( ax.isInf & ax.sign ) ? (sbits32) 0x80000000 : 0x7FFFFFFF;
303     if ( ax.isZero ) return 0;
305     shiftCount = 52 - ax.exp;
307         ax.sig.a1 = 1;
308         ax.sig.a0 = 0;
312             ax.sig = shortShift128RightJamming( ax.sig, 1 );
316     ax = roundFloatXTo53( FALSE, ax );
317     ax.sig = shortShift128RightJamming( ax.sig, 3 );
318     z = ax.sig.a0;
319     if ( ax.sign ) z = - z;
321          || ( ax.sig.a0>>32 )
322          || ( ( z != 0 ) && ( ( ax.sign ^ ( z < 0 ) ) != 0 ) )
325         return ax.sign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
334     floatX ax;
336     ax.isNaN = FALSE;
337     ax.isInf = FALSE;
338     ax.sign = ( a < 0 );
339     ax.sig.a1 = ax.sign ? - a : a;
340     ax.sig.a0 = 0;
342         ax.isZero = TRUE;
343         return ax;
345     ax.isZero = FALSE;
346     ax.sig = shortShift128Left( ax.sig, 56 );
347     ax.exp = 63;
348     while ( ax.sig.a0 < LIT64( 0x0080000000000000 ) ) {
349         ax.sig = shortShift128Left( ax.sig, 1 );
350         --ax.exp;
352     return ax;
356 static int64 floatXToInt64( floatX ax )
362     if ( ax.isInf || ax.isNaN ) {
365               ( ax.isInf & ax.sign ) ? (sbits64) LIT64( 0x8000000000000000 )
368     if ( ax.isZero ) return 0;
370     shiftCount = 112 - ax.exp;
372         ax.sig.a1 = 1;
373         ax.sig.a0 = 0;
377             ax.sig = shortShift128RightJamming( ax.sig, 1 );
381     ax = roundFloatXTo113( FALSE, ax );
382     ax.sig = shortShift128RightJamming( ax.sig, 7 );
383     z = ax.sig.a1;
384     if ( ax.sign ) z = - z;
386          || ax.sig.a0
387          || ( ( z != 0 ) && ( ( ax.sign ^ ( z < 0 ) ) != 0 ) )
391               ax.sign ? (sbits64) LIT64( 0x8000000000000000 )
401     floatX ax;
403     ax.isNaN = FALSE;
404     ax.isInf = FALSE;
405     ax.isZero = FALSE;
406     ax.sign = ( ( a & 0x80000000 ) != 0 );
408     ax.sig.a1 = 0;
409     ax.sig.a0 = a & 0x007FFFFF;
410     ax.sig.a0 <<= 32;
412         if ( ax.sig.a0 == 0 ) {
413             ax.isZero = TRUE;
418                 ax.sig.a0 <<= 1;
420             } while ( ax.sig.a0 < LIT64( 0x0080000000000000 ) );
421             ax.exp = expField;
425         if ( ax.sig.a0 == 0 ) {
426             ax.isInf = TRUE;
429             ax.isNaN = TRUE;
433         ax.sig.a0 |= LIT64( 0x0080000000000000 );
434         ax.exp = expField - 0x7F;
436     return ax;
521     floatX ax;
523     ax.isNaN = FALSE;
524     ax.isInf = FALSE;
525     ax.isZero = FALSE;
526     ax.sign = ( ( a & LIT64( 0x8000000000000000 ) ) != 0 );
528     ax.sig.a1 = 0;
529     ax.sig.a0 = a & LIT64( 0x000FFFFFFFFFFFFF );
531         if ( ax.sig.a0 == 0 ) {
532             ax.isZero = TRUE;
537                 ax.sig.a0 <<= 1;
539             } while ( ax.sig.a0 < LIT64( 0x0010000000000000 ) );
540             ax.exp = expField;
544         if ( ax.sig.a0 == 0 ) {
545             ax.isInf = TRUE;
548             ax.isNaN = TRUE;
552         ax.exp = expField - 0x3FF;
553         ax.sig.a0 |= LIT64( 0x0010000000000000 );
555     ax.sig.a0 <<= 3;
556     return ax;
648     floatX ax;
650     ax.isNaN = FALSE;
651     ax.isInf = FALSE;
652     ax.isZero = FALSE;
653     ax.sign = ( ( a.high & 0x8000 ) != 0 );
655     ax.sig.a1 = a.low;
656     ax.sig.a0 = 0;
658         if ( ax.sig.a1 == 0 ) {
659             ax.isZero = TRUE;
663             while ( ax.sig.a1 < LIT64( 0x8000000000000000 ) ) {
664                 ax.sig.a1 <<= 1;
667             ax.exp = expField;
671         if ( ( ax.sig.a1 & LIT64( 0x7FFFFFFFFFFFFFFF ) ) == 0 ) {
672             ax.isInf = TRUE;
675             ax.isNaN = TRUE;
679         ax.exp = expField - 0x3FFF;
681     ax.sig = shortShift128Left( ax.sig, 56 );
682     return ax;
827     floatX ax;
829     ax.isNaN = FALSE;
830     ax.isInf = FALSE;
831     ax.isZero = FALSE;
832     ax.sign = ( ( a.high & LIT64( 0x8000000000000000 ) ) != 0 );
834     ax.sig.a1 = a.low;
835     ax.sig.a0 = a.high & LIT64( 0x0000FFFFFFFFFFFF );
837         if ( ( ax.sig.a0 == 0 ) && ( ax.sig.a1 == 0 ) ) {
838             ax.isZero = TRUE;
843                 ax.sig = shortShift128Left( ax.sig, 1 );
845             } while ( ax.sig.a0 < LIT64( 0x0001000000000000 ) );
846             ax.exp = expField;
850         if ( ( ax.sig.a0 == 0 ) && ( ax.sig.a1 == 0 ) ) {
851             ax.isInf = TRUE;
854             ax.isNaN = TRUE;
858         ax.exp = expField - 0x3FFF;
859         ax.sig.a0 |= LIT64( 0x0001000000000000 );
861     ax.sig = shortShift128Left( ax.sig, 7 );
862     return ax;
973 static floatX floatXRoundToInt( floatX ax )
977     if ( ax.isNaN || ax.isInf ) return ax;
978     shiftCount = 112 - ax.exp;
979     if ( shiftCount <= 0 ) return ax;
981         ax.exp = 112;
982         ax.sig.a1 = ! ax.isZero;
983         ax.sig.a0 = 0;
987             ax.sig = shortShift128RightJamming( ax.sig, 1 );
988             ++ax.exp;
992     ax = roundFloatXTo113( FALSE, ax );
993     if ( ( ax.sig.a0 == 0 ) && ( ax.sig.a1 == 0 ) ) ax.isZero = TRUE;
994     return ax;
998 static floatX floatXAdd( floatX ax, floatX bx )
1003     if ( ax.isNaN ) return ax;
1005     if ( ax.isInf && bx.isInf ) {
1006         if ( ax.sign == bx.sign ) return ax;
1009     if ( ax.isInf ) return ax;
1011     if ( ax.isZero && bx.isZero ) {
1012         if ( ax.sign == bx.sign ) return ax;
1015     if (    ( ax.sign != bx.sign )
1016          && ( ax.exp == bx.exp )
1017          && eq128( ax.sig, bx.sig )
1025     if ( ax.isZero ) return bx;
1026     if ( bx.isZero ) return ax;
1027     expDiff = ax.exp - bx.exp;
1029         zx = ax;
1041         if ( ax.sign != bx.sign ) zx.sig = neg128( zx.sig );
1047         zx.exp = ax.exp;
1058         if ( ax.sign != bx.sign ) zx.sig = neg128( zx.sig );
1059         zx.sign = ax.sign;
1060         zx.sig = add128( zx.sig, ax.sig );
1070 static floatX floatXMul( floatX ax, floatX bx )
1075     if ( ax.isNaN ) return ax;
1077     if ( ax.isInf ) {
1079         if ( bx.sign ) ax.sign = ! ax.sign;
1080         return ax;
1083         if ( ax.isZero ) return floatXInvalid();
1084         if ( ax.sign ) bx.sign = ! bx.sign;
1087     zx = ax;
1089     if ( ax.isZero || bx.isZero ) {
1096         if ( bx.sig.a1 & 2 ) zx.sig = add128( zx.sig, ax.sig );
1104 static floatX floatXDiv( floatX ax, floatX bx )
1110     if ( ax.isNaN ) return ax;
1112     if ( ax.isInf ) {
1114         if ( bx.sign ) ax.sign = ! ax.sign;
1115         return ax;
1118         if ( ax.isZero ) return floatXInvalid();
1120         if ( ax.sign ) bx.sign = ! bx.sign;
1125     zx = ax;
1127     if ( ax.isZero || bx.isInf ) {
1135         if ( le128( bx.sig, ax.sig ) ) {
1137             ax.sig = add128( ax.sig, negBSig );
1139         ax.sig = shortShift128Left( ax.sig, 1 );
1142     if ( ax.sig.a0 || ax.sig.a1 ) zx.sig.a1 |= 1;
1147 static floatX floatXRem( floatX ax, floatX bx )
1153     if ( ax.isNaN ) return ax;
1155     if ( ax.isInf || bx.isZero ) return floatXInvalid();
1156     if ( ax.isZero || bx.isInf ) return ax;
1158     if ( ax.exp < bx.exp ) return ax;
1161     while ( bx.exp < ax.exp ) {
1162         if ( le128( bx.sig, ax.sig ) ) ax.sig = add128( ax.sig, negBSig );
1163         ax.sig = shortShift128Left( ax.sig, 1 );
1164         --ax.exp;
1166     lastQuotientBit = le128( bx.sig, ax.sig );
1167     if ( lastQuotientBit ) ax.sig = add128( ax.sig, negBSig );
1168     savedASig = ax.sig;
1169     ax.sig = neg128( add128( ax.sig, negBSig ) );
1170     if ( lt128( ax.sig, savedASig ) ) {
1171         ax.sign = ! ax.sign;
1173     else if ( lt128( savedASig, ax.sig ) ) {
1174         ax.sig = savedASig;
1178             ax.sign = ! ax.sign;
1181             ax.sig = savedASig;
1184     if ( ( ax.sig.a0 == 0 ) && ( ax.sig.a1 == 0 ) ) ax.isZero = TRUE;
1185     return ax;
1189 static floatX floatXSqrt( floatX ax )
1195     if ( ax.isNaN || ax.isZero ) return ax;
1196     if ( ax.sign ) return floatXInvalid();
1197     if ( ax.isInf ) return ax;
1198     zx = ax;
1200     if ( ( ax.exp & 1 ) == 0 ) ax.sig = shortShift128RightJamming( ax.sig, 1 );
1206         savedASig = ax.sig;
1207         ax.sig = add128( ax.sig, neg128( zx.sig ) );
1208         ax.sig = shortShift128Left( ax.sig, 1 );
1209         ax.sig = add128( ax.sig, neg128( bitSig ) );
1210         if ( ax.sig.a0 & LIT64( 0x8000000000000000 ) ) {
1211             ax.sig = shortShift128Left( savedASig, 1 );
1219     if ( ax.sig.a0 || ax.sig.a1 ) zx.sig.a1 |= 1;
1224 static flag floatXEq( floatX ax, floatX bx )
1227     if ( ax.isNaN || bx.isNaN ) return FALSE;
1228     if ( ax.isZero && bx.isZero ) return TRUE;
1229     if ( ax.sign != bx.sign ) return FALSE;
1230     if ( ax.isInf || bx.isInf ) return ax.isInf && bx.isInf;
1231     return ( ax.exp == bx.exp ) && eq128( ax.sig, bx.sig );
1235 static flag floatXLe( floatX ax, floatX bx )
1238     if ( ax.isNaN || bx.isNaN ) return FALSE;
1239     if ( ax.isZero && bx.isZero ) return TRUE;
1240     if ( ax.sign != bx.sign ) return ax.sign;
1241     if ( ax.sign ) {
1242         if ( ax.isInf || bx.isZero ) return TRUE;
1243         if ( bx.isInf || ax.isZero ) return FALSE;
1244         if ( bx.exp < ax.exp ) return TRUE;
1245         if ( ax.exp < bx.exp ) return FALSE;
1246         return le128( bx.sig, ax.sig );
1249         if ( bx.isInf || ax.isZero ) return TRUE;
1250         if ( ax.isInf || bx.isZero ) return FALSE;
1251         if ( ax.exp < bx.exp ) return TRUE;
1252         if ( bx.exp < ax.exp ) return FALSE;
1253         return le128( ax.sig, bx.sig );
1258 static flag floatXLt( floatX ax, floatX bx )
1261     if ( ax.isNaN || bx.isNaN ) return FALSE;
1262     if ( ax.isZero && bx.isZero ) return FALSE;
1263     if ( ax.sign != bx.sign ) return ax.sign;
1264     if ( ax.isInf && bx.isInf ) return FALSE;
1265     if ( ax.sign ) {
1266         if ( ax.isInf || bx.isZero ) return TRUE;
1267         if ( bx.isInf || ax.isZero ) return FALSE;
1268         if ( bx.exp < ax.exp ) return TRUE;
1269         if ( ax.exp < bx.exp ) return FALSE;
1270         return lt128( bx.sig, ax.sig );
1273         if ( bx.isInf || ax.isZero ) return TRUE;
1274         if ( ax.isInf || bx.isZero ) return FALSE;
1275         if ( ax.exp < bx.exp ) return TRUE;
1276         if ( bx.exp < ax.exp ) return FALSE;
1277         return lt128( ax.sig, bx.sig );
1492     floatX ax, bx;
1494     ax = float32ToFloatX( a );
1496     if ( ax.isNaN || bx.isNaN ) {
1499     return floatXLe( ax, bx );
1505     floatX ax, bx;
1507     ax = float32ToFloatX( a );
1509     if ( ax.isNaN || bx.isNaN ) {
1512     return floatXLt( ax, bx );
1518     floatX ax, bx;
1520     ax = float32ToFloatX( a );
1522     if ( ax.isNaN || bx.isNaN ) {
1525     return floatXEq( ax, bx );
1681     floatX ax, bx;
1683     ax = float64ToFloatX( a );
1685     if ( ax.isNaN || bx.isNaN ) {
1688     return floatXLe( ax, bx );
1694     floatX ax, bx;
1696     ax = float64ToFloatX( a );
1698     if ( ax.isNaN || bx.isNaN ) {
1701     return floatXLt( ax, bx );
1707     floatX ax, bx;
1709     ax = float64ToFloatX( a );
1711     if ( ax.isNaN || bx.isNaN ) {
1714     return floatXEq( ax, bx );
1868     floatX ax, bx;
1870     ax = floatx80ToFloatX( a );
1872     if ( ax.isNaN || bx.isNaN ) {
1875     return floatXLe( ax, bx );
1881     floatX ax, bx;
1883     ax = floatx80ToFloatX( a );
1885     if ( ax.isNaN || bx.isNaN ) {
1888     return floatXLt( ax, bx );
1894     floatX ax, bx;
1896     ax = floatx80ToFloatX( a );
1898     if ( ax.isNaN || bx.isNaN ) {
1901     return floatXEq( ax, bx );
2057     floatX ax, bx;
2059     ax = float128ToFloatX( a );
2061     if ( ax.isNaN || bx.isNaN ) {
2064     return floatXLe( ax, bx );
2070     floatX ax, bx;
2072     ax = float128ToFloatX( a );
2074     if ( ax.isNaN || bx.isNaN ) {
2077     return floatXLt( ax, bx );
2083     floatX ax, bx;
2085     ax = float128ToFloatX( a );
2087     if ( ax.isNaN || bx.isNaN ) {
2090     return floatXEq( ax, bx );